Перенес необходимые изменения из лабораторной работы №2

This commit is contained in:
Grbisba
2026-11-06 14:27:27 +03:00
parent 0ab3a341aa
commit 4c066ff191
92 changed files with 7156 additions and 7 deletions
+56 -6
View File
@@ -1,9 +1,3 @@
# 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
SESSION_TTL_SECONDS=3600
# Choose credentials locally. File paths contain no secret values.
DATABASE_URL_FILE=/run/secrets/database_url
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
@@ -11,3 +5,59 @@ SESSION_STORE=postgres
CACHE_URL_FILE=/run/secrets/cache_url
API_REPLICAS=2
IDEMPOTENCY_TTL_SECONDS=86400
# Copy to .env and replace both password placeholders for a local synthetic stand.
# Never commit .env. Existing .env files must be updated manually; see REPORT.md.
HOST_PORT=8080
APP_ENABLED=true
APP_HOST=0.0.0.0
APP_PORT=8080
APP_READ_TIMEOUT=5s
APP_WRITE_TIMEOUT=10s
APP_IDLE_TIMEOUT=60s
APP_SHUTDOWN_TIMEOUT=8s
APPLICATION_LOG_LEVEL=info
APPLICATION_ENVIRONMENT=dev
APPLICATION_SHUTDOWN_TIMEOUT=8s
APPLICATION_REQUEST_RATE_LIMIT=100
APPLICATION_BURST_RATE_LIMIT=100
APPLICATION_RATE_LIMIT_TTL=1m
# Container addresses and ports for the Compose network.
# These ports are not published on the host.
POSTGRES_HOST=postgres
POSTGRES_PORT=5432
POSTGRES_USER=messenger
POSTGRES_PASSWORD=replace-with-local-postgres-password
POSTGRES_DATABASE=messenger
POSTGRES_VERSION_TABLE=versions
# Tern applies embedded migrations at API startup.
POSTGRES_RUN_MIGRATIONS=true
POSTGRES_MAX_CONNECTIONS=10
POSTGRES_CONNECT_TIMEOUT=500ms
POSTGRES_QUERY_TIMEOUT=2s
REDIS_HOST=redis
REDIS_PORT=6379
REDIS_USERNAME=default
REDIS_PASSWORD=replace-with-local-redis-password
REDIS_DB=0
SESSION_TTL_SECONDS=3600
JWT_ACCESS_TOKEN_LIFETIME=15m
# Legacy fallback used only when SESSION_TTL_SECONDS is empty.
JWT_REFRESH_TOKEN_LIFETIME=24h
# Container paths. Compose mounts ./certs read-only at /run/certs.
JWT_PUBLIC_KEY_PATH=/run/certs/public_key.pem
JWT_PRIVATE_KEY_PATH=/run/certs/private_key.pem
# Local HTTP defaults. Use secure cookies when serving through HTTPS.
COOKIES_ENABLED=false
COOKIES_DOMAIN=localhost
COOKIES_PATH=/
COOKIES_SECURE=false
COOKIES_SAME_SITE=lax
# Viper accepts a whitespace-separated list of origins.
COOKIES_ALLOWED_ORIGINS=http://localhost:8080
+32
View File
@@ -0,0 +1,32 @@
# syntax=docker/dockerfile:1
FROM --platform=$BUILDPLATFORM golang:1.27.2-alpine3.23 AS build
WORKDIR /src
COPY service/go.mod service/go.sum ./
RUN go mod download
COPY service/ ./
ARG TARGETOS
ARG TARGETARCH
RUN CGO_ENABLED=0 GOOS=$TARGETOS GOARCH=$TARGETARCH \
go build -mod=readonly -trimpath -ldflags="-s -w" -o /out/messenger ./cmd/app
FROM alpine:3.23.6
COPY --from=build --chmod=0555 /out/messenger /usr/local/bin/messenger
ENV APP_HOST=0.0.0.0 \
APP_PORT=8080 \
APP_SHUTDOWN_TIMEOUT=8s
USER 65532:65532
EXPOSE 8080
STOPSIGNAL SIGTERM
HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \
CMD wget -q -O /dev/null "http://127.0.0.1:${APP_PORT}/health/ready" || exit 1
ENTRYPOINT ["/usr/local/bin/messenger"]
+30 -1
View File
@@ -3,8 +3,12 @@ BASE_URL ?= http://localhost:8080
CA_FILE ?=
ACTION_SCRIPT ?=
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
OPENAPI_SPEC := contracts/openapi.json
GEN_OUTPUT := service/internal/gen/contracts/types.gen.go
GEN_PACKAGE := contracts
OAPI_CODEGEN ?= $(shell go env GOPATH)/bin/oapi-codegen
.PHONY: help check validate test load test-persistence test-failover
.PHONY: help check validate test load test-persistence test-failover openapi-generate certs key-gen
help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
@@ -28,3 +32,28 @@ 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)
openapi-generate:
@mkdir -p $(dir $(GEN_OUTPUT))
@echo "Generating Go types from $(OPENAPI_SPEC)..."
@set -o pipefail; \
jq '(.components.schemas.ChatPage.properties.next_cursor.type, .components.schemas.MessagePage.properties.next_cursor.type) |= "string" | (.components.schemas.ChatPage.properties.next_cursor.nullable, .components.schemas.MessagePage.properties.next_cursor.nullable) = true' $(OPENAPI_SPEC) | \
$(OAPI_CODEGEN) -generate types -package $(GEN_PACKAGE) -o $(GEN_OUTPUT) /dev/stdin
key-gen: create-dir gen-private-key gen-public-key
create-dir:
@mkdir -p certs
gen-private-key:
@openssl genrsa -out certs/private_key.pem 2048
gen-public-key:
@openssl rsa -in certs/private_key.pem -pubout -outform PEM -out certs/public_key.pem
certs: gen-key gen-crt
gen-key:
@openssl genrsa -out ./certs/server.key 2048
gen-crt:
@openssl req -new -x509 -key ./certs/server.key -out ./certs/server.crt -days 365
+98
View File
@@ -0,0 +1,98 @@
services:
api:
build:
context: .
dockerfile: Dockerfile
container_name: api
image: mtusi-messenger:lab2
restart: unless-stopped
environment:
APP_ENABLED: "true"
APP_HOST: ${APP_HOST:-0.0.0.0}
APP_PORT: ${APP_PORT:-8080}
APP_READ_TIMEOUT: ${APP_READ_TIMEOUT:-5s}
APP_WRITE_TIMEOUT: ${APP_WRITE_TIMEOUT:-10s}
APP_IDLE_TIMEOUT: ${APP_IDLE_TIMEOUT:-60s}
APP_SHUTDOWN_TIMEOUT: ${APP_SHUTDOWN_TIMEOUT:-8s}
APPLICATION_LOG_LEVEL: ${APPLICATION_LOG_LEVEL:-info}
APPLICATION_ENVIRONMENT: ${APPLICATION_ENVIRONMENT:-dev}
APPLICATION_SHUTDOWN_TIMEOUT: ${APPLICATION_SHUTDOWN_TIMEOUT:-8s}
APPLICATION_REQUEST_RATE_LIMIT: ${APPLICATION_REQUEST_RATE_LIMIT:-100}
APPLICATION_BURST_RATE_LIMIT: ${APPLICATION_BURST_RATE_LIMIT:-100}
APPLICATION_RATE_LIMIT_TTL: ${APPLICATION_RATE_LIMIT_TTL:-1m}
POSTGRES_HOST: ${POSTGRES_HOST:-postgres}
POSTGRES_PORT: ${POSTGRES_PORT:-5432}
POSTGRES_USER: ${POSTGRES_USER:-messenger}
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env}
POSTGRES_DATABASE: ${POSTGRES_DATABASE:-messenger}
POSTGRES_VERSION_TABLE: ${POSTGRES_VERSION_TABLE:-versions}
POSTGRES_RUN_MIGRATIONS: ${POSTGRES_RUN_MIGRATIONS:-true}
POSTGRES_MAX_CONNECTIONS: ${POSTGRES_MAX_CONNECTIONS:-10}
POSTGRES_CONNECT_TIMEOUT: ${POSTGRES_CONNECT_TIMEOUT:-500ms}
POSTGRES_QUERY_TIMEOUT: ${POSTGRES_QUERY_TIMEOUT:-2s}
REDIS_HOST: ${REDIS_HOST:-redis}
REDIS_PORT: ${REDIS_PORT:-6379}
REDIS_USERNAME: ${REDIS_USERNAME:-default}
REDIS_PASSWORD: ${REDIS_PASSWORD:?Set REDIS_PASSWORD in .env}
REDIS_DB: ${REDIS_DB:-0}
JWT_ACCESS_TOKEN_LIFETIME: ${JWT_ACCESS_TOKEN_LIFETIME:-15m}
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-}
JWT_REFRESH_TOKEN_LIFETIME: ${JWT_REFRESH_TOKEN_LIFETIME:-}
JWT_PUBLIC_KEY_PATH: ${JWT_PUBLIC_KEY_PATH:-/run/certs/public_key.pem}
JWT_PRIVATE_KEY_PATH: ${JWT_PRIVATE_KEY_PATH:-/run/certs/private_key.pem}
depends_on:
postgres:
condition: service_healthy
volumes:
- type: bind
source: ./certs
target: /run/certs
read_only: true
bind:
create_host_path: false
ports:
- "127.0.0.1:${HOST_PORT:-8080}:8080"
stop_grace_period: 10s
postgres:
image: postgres:17.11-alpine3.23
restart: unless-stopped
environment:
POSTGRES_USER: ${POSTGRES_USER:-messenger}
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env}
POSTGRES_DB: ${POSTGRES_DATABASE:-messenger}
volumes:
- postgres_data:/var/lib/postgresql/data
healthcheck:
test: [ "CMD-SHELL", "pg_isready -h 127.0.0.1 -U \"$${POSTGRES_USER}\" -d \"$${POSTGRES_DB}\"" ]
interval: 5s
timeout: 3s
start_period: 30s
retries: 12
stop_grace_period: 60s
redis:
image: redis:8.2.11-alpine3.22
restart: unless-stopped
environment:
REDIS_PASSWORD: ${REDIS_PASSWORD:?Set REDIS_PASSWORD in .env}
# Redis does not apply REDIS_PASSWORD by itself. Re-enter its entrypoint
# with redis-server so it also drops privileges to the redis user.
command:
- sh
- -c
- exec docker-entrypoint.sh redis-server --appendonly yes --appendfsync everysec --requirepass "$$REDIS_PASSWORD"
volumes:
- redis_data:/data
healthcheck:
test: [ "CMD-SHELL", "REDISCLI_AUTH=\"$${REDIS_PASSWORD}\" redis-cli --no-auth-warning ping | grep -qx PONG" ]
interval: 5s
timeout: 3s
start_period: 5s
retries: 12
stop_grace_period: 30s
volumes:
postgres_data:
redis_data:
+111
View File
@@ -0,0 +1,111 @@
package main
import (
"context"
"fmt"
"log/slog"
"os"
"os/signal"
"syscall"
"time"
"gitea.privcloud.tech/mtusi2026/internal/adapter/controller/http"
"gitea.privcloud.tech/mtusi2026/internal/adapter/repository/cache/outside"
"gitea.privcloud.tech/mtusi2026/internal/adapter/repository/storage"
"gitea.privcloud.tech/mtusi2026/internal/config"
"gitea.privcloud.tech/mtusi2026/internal/pkg/auth/jwtprovider"
"gitea.privcloud.tech/mtusi2026/internal/pkg/cache"
"gitea.privcloud.tech/mtusi2026/internal/pkg/encrypting"
"gitea.privcloud.tech/mtusi2026/internal/pkg/migrator"
"gitea.privcloud.tech/mtusi2026/internal/pkg/postgres"
"gitea.privcloud.tech/mtusi2026/internal/pkg/postgres/txmanager"
"gitea.privcloud.tech/mtusi2026/internal/pkg/rest/middleware"
"gitea.privcloud.tech/mtusi2026/internal/pkg/rest/router"
"gitea.privcloud.tech/mtusi2026/internal/pkg/validator"
"gitea.privcloud.tech/mtusi2026/internal/service/auth"
"gitea.privcloud.tech/mtusi2026/internal/service/chat"
"gitea.privcloud.tech/mtusi2026/internal/service/user"
)
func main() {
time.Local = time.UTC
if err := run(); err != nil {
slog.Error("application stopped", "error", err)
os.Exit(1)
}
}
func run() error {
cfg, err := config.New()
if err != nil {
return fmt.Errorf("load server config: %w", err)
}
pgx := postgres.New(cfg.Postgres)
rx := cache.New(cfg)
postgresMigrator := migrator.New(cfg)
tm := txmanager.New(pgx)
provider := jwtprovider.New(cfg)
encryptor := encrypting.New()
chatsRepo := storage.NewChatsRepo(pgx)
messageRepo := storage.NewMessagesRepo(pgx)
refreshTokensRepo := storage.NewRefreshTokensRepo(pgx)
userRepo := storage.NewUsersRepo(pgx)
chatCache := outside.NewChatCache(rx)
authSvc := auth.New(provider, tm, encryptor, userRepo, refreshTokensRepo)
userSvc := user.New(encryptor, userRepo)
chatSvc := chat.New(tm, chatsRepo, messageRepo, chatCache)
httpRouter := router.New(
middleware.NewAuthMiddleware(authSvc),
middleware.RequestIDMiddleware(),
middleware.LoggingMiddleware(),
middleware.RequestTimeout(cfg.Postgres.QueryTimeout),
)
server := http.New(cfg, httpRouter)
requestValidator := validator.NewValidatorImpl()
registerRoutes(
http.NewAuthHandler(httpRouter, authSvc),
http.NewHealthHandler(httpRouter, server, pgx),
http.NewChatHandler(httpRouter, provider, requestValidator, chatSvc),
http.NewUserHandler(httpRouter, provider, requestValidator, userSvc),
)
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
defer stop()
if err = postgresMigrator.Start(ctx); err != nil {
return fmt.Errorf("start postgres migrator: %w", err)
}
if err = server.Start(ctx); err != nil {
return fmt.Errorf("start HTTP server: %w", err)
}
if err = rx.Start(ctx); err != nil {
slog.Warn("redis unavailable at startup; continuing without cache", "error", err)
}
slog.Info("HTTP server started", "address", cfg.Server.BindAddress())
<-ctx.Done()
shutdownCtx, cancel := context.WithTimeout(context.Background(), cfg.Server.ShutdownTimeout)
defer cancel()
if err = server.Stop(shutdownCtx); err != nil {
return fmt.Errorf("stop HTTP server: %w", err)
}
if err = postgresMigrator.Close(shutdownCtx); err != nil {
return fmt.Errorf("close postgres migrator: %w", err)
}
if err = rx.Close(); err != nil {
return fmt.Errorf("close redis: %w", err)
}
pgx.Close()
return nil
}
func registerRoutes(handlers ...http.Handler) {
for _, handler := range handlers {
handler.RegisterRoutes()
}
}
+386
View File
@@ -0,0 +1,386 @@
// Command benchmark measures the lab1 HTTP API in fresh, resource-limited containers.
package main
import (
"bytes"
"encoding/json"
"errors"
"flag"
"fmt"
"io"
"math"
"net/http"
"os"
"os/exec"
"path/filepath"
"slices"
"strconv"
"strings"
"sync"
"time"
)
const (
container = "mtusi-inmemory-benchmark"
baseURL = "http://127.0.0.1:18093"
)
type runResult struct {
History int `json:"history"`
Concurrency int `json:"concurrency"`
Repetition int `json:"repetition"`
ElapsedSeconds float64 `json:"elapsed_seconds"`
ReadSuccess int `json:"read_success"`
WriteSuccess int `json:"write_success"`
Errors int `json:"errors"`
SuccessfulRPS float64 `json:"successful_rps"`
LatencyMS map[string]float64 `json:"latency_ms"`
RSSBeforeKiB int `json:"rss_kib_before"`
RSSPeakKiB int `json:"rss_kib_peak"`
}
type report struct {
Image string `json:"image"`
Method map[string]any `json:"method"`
Runs []runResult `json:"runs"`
}
type workerResult struct {
reads int
writes int
errors int
latencies []float64
}
type memoryResult struct {
peak int
err error
}
func docker(args ...string) (string, error) {
command := exec.Command("docker", args...)
output, err := command.CombinedOutput()
if err != nil {
return "", fmt.Errorf("docker %s: %w: %s", strings.Join(args, " "), err, strings.TrimSpace(string(output)))
}
return strings.TrimSpace(string(output)), nil
}
func rssKiB() (int, error) {
status, err := docker("exec", container, "cat", "/proc/1/status")
if err != nil {
return 0, err
}
for line := range strings.SplitSeq(status, "\n") {
if strings.HasPrefix(line, "VmRSS:") {
fields := strings.Fields(line)
return strconv.Atoi(fields[1])
}
}
return 0, errors.New("VmRSS is unavailable")
}
func newClient(timeout time.Duration) *http.Client {
return &http.Client{
Timeout: timeout,
Transport: &http.Transport{
MaxConnsPerHost: 1,
MaxIdleConnsPerHost: 1,
IdleConnTimeout: 30 * time.Second,
},
}
}
func request(client *http.Client, method, path, user string, body any) (map[string]any, error) {
var data io.Reader
if body != nil {
encoded, err := json.Marshal(body)
if err != nil {
return nil, err
}
data = bytes.NewReader(encoded)
}
req, err := http.NewRequest(method, baseURL+path, data)
if err != nil {
return nil, err
}
req.Header.Set("Accept", "application/json")
if user != "" {
req.Header.Set("X-User-Id", user)
}
if body != nil {
req.Header.Set("Content-Type", "application/json")
}
response, err := client.Do(req)
if err != nil {
return nil, err
}
defer response.Body.Close()
content, err := io.ReadAll(io.LimitReader(response.Body, 1<<20))
if err != nil {
return nil, err
}
if response.StatusCode != http.StatusOK && response.StatusCode != http.StatusCreated {
return nil, fmt.Errorf("%s %s: HTTP %d: %s", method, path, response.StatusCode, content)
}
var payload map[string]any
if err := json.Unmarshal(content, &payload); err != nil {
return nil, err
}
return payload, nil
}
func stringField(payload map[string]any, key string) (string, error) {
value, ok := payload[key].(string)
if !ok || value == "" {
return "", fmt.Errorf("missing %s in API response", key)
}
return value, nil
}
func percentile(sorted []float64, proportion float64) float64 {
if len(sorted) == 0 {
return 0
}
index := int(math.Ceil(float64(len(sorted))*proportion)) - 1
if index < 0 {
index = 0
}
return round(sorted[index], 3)
}
func round(value float64, places int) float64 {
shift := math.Pow10(places)
return math.Round(value*shift) / shift
}
func sampleMemory(stop <-chan struct{}, initial int, result chan<- memoryResult) {
ticker := time.NewTicker(250 * time.Millisecond)
defer ticker.Stop()
peak := initial
for {
select {
case <-stop:
result <- memoryResult{peak: peak}
return
case <-ticker.C:
rss, err := rssKiB()
if err != nil {
result <- memoryResult{err: err}
return
}
peak = max(peak, rss)
}
}
}
func runCase(image string, history, concurrency, repetition int, duration time.Duration) (runResult, error) {
row := runResult{History: history, Concurrency: concurrency, Repetition: repetition}
if _, err := docker("run", "-d", "--name", container, "--cpus=1", "--memory=512m",
"-p", "127.0.0.1:18093:8080", image); err != nil {
return row, err
}
defer func() { _, _ = docker("rm", "-f", container) }()
setup := newClient(2 * time.Second)
defer setup.CloseIdleConnections()
readyDeadline := time.Now().Add(20 * time.Second)
for {
if _, err := request(setup, http.MethodGet, "/health/ready", "", nil); err == nil {
break
} else if time.Now().After(readyDeadline) {
return row, fmt.Errorf("server did not become ready: %w", err)
}
time.Sleep(100 * time.Millisecond)
}
userResponse, err := request(setup, http.MethodPost, "/api/v1/users", "", map[string]any{
"username": fmt.Sprintf("bench_%d_%d_%d", time.Now().UnixNano(), history, repetition),
"display_name": "Benchmark",
})
if err != nil {
return row, err
}
user, err := stringField(userResponse, "id")
if err != nil {
return row, err
}
chatResponse, err := request(setup, http.MethodPost, "/api/v1/chats", user, map[string]any{
"title": "Benchmark", "member_ids": []string{user},
})
if err != nil {
return row, err
}
chat, err := stringField(chatResponse, "id")
if err != nil {
return row, err
}
path := "/api/v1/chats/" + chat + "/messages"
for index := range history {
if _, err := request(setup, http.MethodPost, path, user, map[string]string{
"text": fmt.Sprintf("seed-%d", index),
}); err != nil {
return row, fmt.Errorf("seed message %d: %w", index, err)
}
}
row.RSSBeforeKiB, err = rssKiB()
if err != nil {
return row, err
}
start := make(chan struct{})
results := make(chan workerResult, concurrency)
stopSampling := make(chan struct{})
memory := make(chan memoryResult, 1)
go sampleMemory(stopSampling, row.RSSBeforeKiB, memory)
var group sync.WaitGroup
group.Add(concurrency)
deadline := time.Now().Add(duration)
started := time.Now()
for workerID := range concurrency {
go func() {
defer group.Done()
local := newClient(5 * time.Second)
defer local.CloseIdleConnections()
result := workerResult{}
<-start
for index := 0; time.Now().Before(deadline); index++ {
began := time.Now()
var err error
if index%10 == 0 {
_, err = request(local, http.MethodPost, path, user, map[string]string{
"text": fmt.Sprintf("load-%d-%d-%d", repetition, workerID, index),
})
if err == nil {
result.writes++
}
} else {
var page map[string]any
page, err = request(local, http.MethodGet, path+"?limit=50", user, nil)
if err == nil {
items, ok := page["items"].([]any)
if !ok || len(items) != 50 {
err = errors.New("short first page")
} else {
result.reads++
}
}
}
if err != nil {
result.errors++
} else {
result.latencies = append(result.latencies, float64(time.Since(began).Microseconds())/1000)
}
}
results <- result
}()
}
close(start)
group.Wait()
row.ElapsedSeconds = round(time.Since(started).Seconds(), 3)
close(stopSampling)
memorySample := <-memory
if memorySample.err != nil {
return row, memorySample.err
}
row.RSSPeakKiB = memorySample.peak
if finalRSS, err := rssKiB(); err == nil {
row.RSSPeakKiB = max(row.RSSPeakKiB, finalRSS)
} else {
return row, err
}
latencies := make([]float64, 0)
for range concurrency {
result := <-results
row.ReadSuccess += result.reads
row.WriteSuccess += result.writes
row.Errors += result.errors
latencies = append(latencies, result.latencies...)
}
if len(latencies) == 0 {
return row, errors.New("no successful requests")
}
slices.Sort(latencies)
row.SuccessfulRPS = round(float64(len(latencies))/row.ElapsedSeconds, 2)
row.LatencyMS = map[string]float64{
"p95": percentile(latencies, 0.95),
"p99": percentile(latencies, 0.99),
}
return row, nil
}
func parseValues(raw string, minimum int) ([]int, error) {
values := make([]int, 0)
for part := range strings.SplitSeq(raw, ",") {
value, err := strconv.Atoi(strings.TrimSpace(part))
if err != nil || value < minimum {
return nil, fmt.Errorf("invalid value %q", part)
}
values = append(values, value)
}
return values, nil
}
func save(path string, data report) error {
encoded, err := json.MarshalIndent(data, "", " ")
if err != nil {
return err
}
if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
return err
}
return os.WriteFile(path, append(encoded, '\n'), 0o644)
}
func main() {
image := flag.String("image", "", "Docker image to benchmark")
output := flag.String("output", "", "JSON output path")
historiesArg := flag.String("histories", "100,500,1500", "Comma-separated history sizes")
concurrenciesArg := flag.String("concurrencies", "1,4,10", "Comma-separated client counts")
repeats := flag.Int("repeats", 3, "Runs per combination")
duration := flag.Duration("duration", 5*time.Second, "Measured duration per run")
flag.Parse()
if *image == "" || *output == "" || *repeats < 1 || *duration <= 0 {
fmt.Fprintln(os.Stderr, "image, output, positive repeats and duration are required")
os.Exit(2)
}
histories, err := parseValues(*historiesArg, 50)
if err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(2)
}
concurrencies, err := parseValues(*concurrenciesArg, 1)
if err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(2)
}
data := report{
Image: *image,
Method: map[string]any{
"histories": histories, "concurrencies": concurrencies,
"repeats": *repeats, "duration_seconds": duration.Seconds(),
"mix": "90% first-page GET, 10% POST per client; persistent HTTP connections",
"limits": "1 CPU, 512 MiB; fresh container and history per case",
"rss": "VmRSS from /proc/1/status every 250 ms (sampled peak)",
"latency": "successful requests only; errors counted separately; closed-loop workload",
},
Runs: make([]runResult, 0, len(histories)*len(concurrencies)*(*repeats)),
}
for _, history := range histories {
for _, concurrency := range concurrencies {
for repetition := 1; repetition <= *repeats; repetition++ {
row, err := runCase(*image, history, concurrency, repetition, *duration)
if err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
data.Runs = append(data.Runs, row)
if err := save(*output, data); err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
encoded, _ := json.Marshal(row)
fmt.Println(string(encoded))
}
}
}
}
+57
View File
@@ -0,0 +1,57 @@
module gitea.privcloud.tech/mtusi2026
go 1.27.0
require (
github.com/go-chi/chi/v5 v5.5.0
github.com/go-playground/validator/v10 v10.30.5
github.com/golang-jwt/jwt/v5 v5.3.1
github.com/google/uuid v1.6.0
github.com/jackc/pgerrcode v0.0.0-20250907135507-afb5586c32a6
github.com/jackc/pgx/v5 v5.11.0
github.com/oapi-codegen/runtime v1.4.2
github.com/redis/go-redis/v9 v9.23.0
github.com/spf13/viper v1.21.0
go.uber.org/multierr v1.11.0
golang.org/x/crypto v0.57.0
golang.org/x/sync v0.23.0
google.golang.org/grpc v1.85.0
)
require (
dario.cat/mergo v1.0.2 // indirect
github.com/Masterminds/goutils v1.1.1 // indirect
github.com/Masterminds/semver/v3 v3.5.0 // indirect
github.com/Masterminds/sprig/v3 v3.3.0 // indirect
github.com/Masterminds/squirrel v1.5.4 // indirect
github.com/cespare/xxhash/v2 v2.3.0 // indirect
github.com/fsnotify/fsnotify v1.9.0 // indirect
github.com/gabriel-vasile/mimetype v1.4.15 // indirect
github.com/go-playground/locales v0.14.1 // indirect
github.com/go-playground/universal-translator v0.18.1 // indirect
github.com/go-viper/mapstructure/v2 v2.4.0 // indirect
github.com/huandu/xstrings v1.5.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
github.com/jackc/tern/v2 v2.4.3 // indirect
github.com/lann/builder v0.0.0-20180802200727-47ae307949d0 // indirect
github.com/lann/ps v0.0.0-20150810152359-62de8c46ede0 // indirect
github.com/leodido/go-urn v1.5.0 // indirect
github.com/mcosta74/pgx-slog v0.4.1 // indirect
github.com/mitchellh/copystructure v1.2.0 // indirect
github.com/mitchellh/reflectwalk v1.0.2 // indirect
github.com/pelletier/go-toml/v2 v2.4.3-0.20260624044523-35f78d5908f1 // indirect
github.com/sagikazarmark/locafero v0.11.0 // indirect
github.com/shopspring/decimal v1.4.0 // indirect
github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8 // indirect
github.com/spf13/afero v1.15.0 // indirect
github.com/spf13/cast v1.10.0 // indirect
github.com/spf13/pflag v1.0.10 // indirect
github.com/subosito/gotenv v1.6.0 // indirect
github.com/vgarvardt/pgx-google-uuid/v5 v5.6.0 // indirect
go.uber.org/atomic v1.12.0 // indirect
go.yaml.in/yaml/v3 v3.0.5 // indirect
golang.org/x/sys v0.48.0 // indirect
golang.org/x/text v0.42.0 // indirect
)
+131
View File
@@ -0,0 +1,131 @@
dario.cat/mergo v1.0.2 h1:85+piFYR1tMbRrLcDwR18y4UKJ3aH1Tbzi24VRW1TK8=
dario.cat/mergo v1.0.2/go.mod h1:E/hbnu0NxMFBjpMIE34DRGLWqDy0g5FuKDhCb31ngxA=
github.com/Masterminds/goutils v1.1.1 h1:5nUrii3FMTL5diU80unEVvNevw1nH4+ZV4DSLVJLSYI=
github.com/Masterminds/goutils v1.1.1/go.mod h1:8cTjp+g8YejhMuvIA5y2vz3BpJxksy863GQaJW2MFNU=
github.com/Masterminds/semver/v3 v3.5.0 h1:kQceYJfbupGfZOKZQg0kou0DgAKhzDg2NZPAwZ/2OOE=
github.com/Masterminds/semver/v3 v3.5.0/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lprf4nC11bSS5beM=
github.com/Masterminds/sprig/v3 v3.3.0 h1:mQh0Yrg1XPo6vjYXgtf5OtijNAKJRNcTdOOGZe3tPhs=
github.com/Masterminds/sprig/v3 v3.3.0/go.mod h1:Zy1iXRYNqNLUolqCpL4uhk6SHUMAOSCzdgBfDb35Lz0=
github.com/Masterminds/squirrel v1.5.4 h1:uUcX/aBc8O7Fg9kaISIUsHXdKuqehiXAMQTYX8afzqM=
github.com/Masterminds/squirrel v1.5.4/go.mod h1:NNaOrjSoIDfDA40n7sr2tPNZRfjzjA400rg+riTZj10=
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/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=
github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0=
github.com/gabriel-vasile/mimetype v1.4.15 h1:05iP/CYtZ/w455R/KZM6rZ5ieAdh99UPtd+d3YzLmaI=
github.com/gabriel-vasile/mimetype v1.4.15/go.mod h1:azpTcoLcDZRNgFou5j+APrqQx9HqVPWa6ijYQIIVswQ=
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/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
github.com/go-playground/validator/v10 v10.30.5 h1:YyCXvVShZbs2Sm3Mb53eNOlhRXctSOzW5QJAouCTZL4=
github.com/go-playground/validator/v10 v10.30.5/go.mod h1:wEqiaov48pXX1kjhc3Da8y0M0Dtg/BK7gurFBLgwFrQ=
github.com/go-viper/mapstructure/v2 v2.4.0 h1:EBsztssimR/CONLSZZ04E8qAkxNYq4Qp9LvH92wZUgs=
github.com/go-viper/mapstructure/v2 v2.4.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM=
github.com/golang-jwt/jwt/v5 v5.3.1 h1:kYf81DTWFe7t+1VvL7eS+jKFVWaUnK9cB1qbwn63YCY=
github.com/golang-jwt/jwt/v5 v5.3.1/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE=
github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
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/huandu/xstrings v1.5.0 h1:2ag3IFq9ZDANvthTwTiqSSZLjDc+BedvHPAp5tJy2TI=
github.com/huandu/xstrings v1.5.0/go.mod h1:y5/lhBue+AyNmUVz9RLU9xbLR0o4KIIExikq4ovT0aE=
github.com/jackc/pgerrcode v0.0.0-20250907135507-afb5586c32a6 h1:D/V0gu4zQ3cL2WKeVNVM4r2gLxGGf6McLwgXzRTo2RQ=
github.com/jackc/pgerrcode v0.0.0-20250907135507-afb5586c32a6/go.mod h1:a/s9Lp5W7n/DD0VrVoyJ00FbP2ytTPDVOivvn2bMlds=
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/jackc/tern/v2 v2.4.3 h1:g293d3OZgW7OFEhsYXgEv0C21jea2boNr0VR4K5I7OY=
github.com/jackc/tern/v2 v2.4.3/go.mod h1:rMpMuRYcff5wWLptoTSO1qcDxJ4OodysvK17i2SVBys=
github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
github.com/lann/builder v0.0.0-20180802200727-47ae307949d0 h1:SOEGU9fKiNWd/HOJuq6+3iTQz8KNCLtVX6idSoTLdUw=
github.com/lann/builder v0.0.0-20180802200727-47ae307949d0/go.mod h1:dXGbAdH5GtBTC4WfIxhKZfyBF/HBFgRZSWwZ9g/He9o=
github.com/lann/ps v0.0.0-20150810152359-62de8c46ede0 h1:P6pPBnrTSX3DEVR4fDembhRWSsG5rVo6hYhAB/ADZrk=
github.com/lann/ps v0.0.0-20150810152359-62de8c46ede0/go.mod h1:vmVJ0l/dxyfGW6FmdpVm2joNMFikkuWg0EoCKLGUMNw=
github.com/leodido/go-urn v1.5.0 h1:pLqT2kq1zpHW/1D18QMjMpdtX7cekxqtJJjg5ANyWw0=
github.com/leodido/go-urn v1.5.0/go.mod h1:9BORnCDhdPBJNDEX+w1bJisa8yOKYi116VeO96s4ifE=
github.com/mcosta74/pgx-slog v0.4.1 h1:Rt25l/jE5tu1ioqPDrqY17Kv6REdsM0L9WCT+hFw1rw=
github.com/mcosta74/pgx-slog v0.4.1/go.mod h1:BCpubkiENkWQ8MvZ4a9LJgWuBzC5UpWoJmQ1/SOlv+M=
github.com/mitchellh/copystructure v1.2.0 h1:vpKXTN4ewci03Vljg/q9QvCGUDttBOGBIa15WveJJGw=
github.com/mitchellh/copystructure v1.2.0/go.mod h1:qLl+cE2AmVv+CoeAwDPye/v+N2HKCj9FbZEVFJRxO9s=
github.com/mitchellh/reflectwalk v1.0.2 h1:G2LzWKi524PWgd3mLHV8Y5k7s6XUvT0Gef6zxSIeXaQ=
github.com/mitchellh/reflectwalk v1.0.2/go.mod h1:mSTlrgnPZtwu0c4WaC2kGObEpuNDbx0jmZXqmk4esnw=
github.com/oapi-codegen/runtime v1.4.2 h1:GMxFVYLzoYLua+/KvzgSphkyK1lLTReQI9Vf4hvATKE=
github.com/oapi-codegen/runtime v1.4.2/go.mod h1:GwV7hC2hviaMzj+ITfHVRESK5J2W/GefVwIND/bMGvU=
github.com/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0t5Ec4=
github.com/pelletier/go-toml/v2 v2.2.4/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY=
github.com/pelletier/go-toml/v2 v2.4.3-0.20260624044523-35f78d5908f1 h1:gIZQQ2+wbsdQGWLPDSdJFptR25tBCjSC0KbSIQZ1rgE=
github.com/pelletier/go-toml/v2 v2.4.3-0.20260624044523-35f78d5908f1/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
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/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8=
github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
github.com/sagikazarmark/locafero v0.11.0 h1:1iurJgmM9G3PA/I+wWYIOw/5SyBtxapeHDcg+AAIFXc=
github.com/sagikazarmark/locafero v0.11.0/go.mod h1:nVIGvgyzw595SUSUE6tvCp3YYTeHs15MvlmU87WwIik=
github.com/shopspring/decimal v1.4.0 h1:bxl37RwXBklmTi0C79JfXCEBD1cqqHt0bbgBAGFp81k=
github.com/shopspring/decimal v1.4.0/go.mod h1:gawqmDU56v4yIKSwfBSFip1HdCCXN8/+DMd9qYNcwME=
github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8 h1:+jumHNA0Wrelhe64i8F6HNlS8pkoyMv5sreGx2Ry5Rw=
github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8/go.mod h1:3n1Cwaq1E1/1lhQhtRK2ts/ZwZEhjcQeJQ1RuC6Q/8U=
github.com/spf13/afero v1.15.0 h1:b/YBCLWAJdFWJTN9cLhiXXcD7mzKn9Dm86dNnfyQw1I=
github.com/spf13/afero v1.15.0/go.mod h1:NC2ByUVxtQs4b3sIUphxK0NioZnmxgyCrfzeuq8lxMg=
github.com/spf13/cast v1.10.0 h1:h2x0u2shc1QuLHfxi+cTJvs30+ZAHOGRic8uyGTDWxY=
github.com/spf13/cast v1.10.0/go.mod h1:jNfB8QC9IA6ZuY2ZjDp0KtFO2LZZlg4S/7bzP6qqeHo=
github.com/spf13/pflag v1.0.10 h1:4EBh2KAYBwaONj6b2Ye1GiHfwjqyROoF4RwYO+vPwFk=
github.com/spf13/pflag v1.0.10/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
github.com/spf13/viper v1.21.0 h1:x5S+0EU27Lbphp4UKm1C+1oQO+rKx36vfCoaVebLFSU=
github.com/spf13/viper v1.21.0/go.mod h1:P0lhsswPGWD/1lZJ9ny3fYnVqxiegrlNrEmgLjbTCAY=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
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.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8=
github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU=
github.com/vgarvardt/pgx-google-uuid/v5 v5.6.0 h1:EhPtK0mgrgaTMXpegE69hvoSOVC1Ahk8+QJ9B8b+OdU=
github.com/vgarvardt/pgx-google-uuid/v5 v5.6.0/go.mod h1:5LtFrNEkgzxHvXPO9eOvcXsSn9/KeKYgx9kjeI2oXQI=
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.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc=
go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
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.57.0 h1:3ZVCjf8Ggz7zneR/EHRVx68Ctf+2pmIMP2UFhh9cC6M=
golang.org/x/crypto v0.57.0/go.mod h1:Fdz0i5U6CoizGwLda9DttjSk6qlZo25zYNtR+ycvuZA=
golang.org/x/sync v0.23.0 h1:KameEIfc1IkluZyXWLn39Wd4tURc6GbCiISGiZm2bQk=
golang.org/x/sync v0.23.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0=
golang.org/x/sys v0.48.0 h1:bbX/i/6MgT9BVLM9RT1thmxL04yeTAhbEz4SyadbXoo=
golang.org/x/sys v0.48.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og=
golang.org/x/text v0.42.0 h1:JbOZXgfeCPU9gacVtYliJqOhD+zhrEqK4LfdpmlUZqI=
golang.org/x/text v0.42.0/go.mod h1:ojzP1Z+2QtioaF8DTtO8K5q7JWVVYwZKenzujK0Zd0E=
google.golang.org/grpc v1.85.0 h1:BPBCfuVRQ1qvBhKDOq9uvQllMvO59rKsYhXpp7Dd8vw=
google.golang.org/grpc v1.85.0/go.mod h1:0rQrOD58yjal/0EaVbGBANindixsCZNQPDV3VKtaKuQ=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
@@ -0,0 +1,88 @@
package http
import (
"net/http"
"gitea.privcloud.tech/mtusi2026/internal/dto"
"gitea.privcloud.tech/mtusi2026/internal/gen/contracts"
"gitea.privcloud.tech/mtusi2026/internal/pkg/apperr"
"gitea.privcloud.tech/mtusi2026/internal/pkg/rest/framework"
"gitea.privcloud.tech/mtusi2026/internal/pkg/rest/router"
"gitea.privcloud.tech/mtusi2026/internal/service/auth"
)
type AuthHandler struct {
router router.Router
auth auth.API
}
func NewAuthHandler(r router.Router, api auth.API) Handler {
return &AuthHandler{
router: r,
auth: api,
}
}
func (h *AuthHandler) RegisterRoutes() {
h.router.Public(http.MethodPost, "/api/v1/auth/sessions", h.Login)
h.router.Private(http.MethodDelete, "/api/v1/auth/sessions/current", h.Logout)
}
func (h *AuthHandler) Login(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
username, password, ok := r.BasicAuth()
if !ok || username == "" || password == "" {
w.Header().Set(
"WWW-Authenticate",
`Basic realm="messenger", charset="UTF-8"`,
)
framework.JSONError(ctx, w, apperr.New(apperr.CodeUnauthorized, "invalid credentials"))
return
}
resp, err := h.auth.Login(ctx, dto.Login{
Username: username,
Password: password,
})
if err != nil {
if apperr.HTTPStatusFromError(err) == http.StatusUnauthorized {
w.Header().Set("WWW-Authenticate", `Basic realm="messenger", charset="UTF-8"`)
}
framework.JSONError(ctx, w, err)
return
}
framework.JSONResponse(w, http.StatusCreated, contracts.Session{
ExpiresAt: resp.ExpiresAt,
Token: resp.Tokens.RefreshToken.Payload,
TokenType: resp.TokenType,
User: contracts.User{
CreatedAt: resp.User.CreatedAt,
DisplayName: resp.User.DisplayName,
Id: resp.User.ID,
Username: resp.User.Username,
},
})
}
func (h *AuthHandler) Logout(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
token, exists := framework.Token(r)
if !exists {
framework.JSONError(ctx, w, apperr.New(apperr.CodeUnauthorized, "missing token in header"))
return
}
err := h.auth.Logout(ctx, dto.RefreshToken{
Payload: token,
})
if err != nil {
framework.JSONError(ctx, w, err)
return
}
framework.JSONResponse(w, http.StatusNoContent, nil)
}
@@ -0,0 +1,261 @@
package http
import (
"net/http"
"strings"
"unicode/utf8"
"github.com/google/uuid"
"gitea.privcloud.tech/mtusi2026/internal/dto"
"gitea.privcloud.tech/mtusi2026/internal/gen/contracts"
"gitea.privcloud.tech/mtusi2026/internal/pkg/apperr"
"gitea.privcloud.tech/mtusi2026/internal/pkg/auth/jwtprovider"
"gitea.privcloud.tech/mtusi2026/internal/pkg/rest/framework"
"gitea.privcloud.tech/mtusi2026/internal/pkg/rest/router"
"gitea.privcloud.tech/mtusi2026/internal/pkg/validator"
"gitea.privcloud.tech/mtusi2026/internal/service/chat"
)
type ChatHandler struct {
router router.Router
provider jwtprovider.Provider
validator *validator.ValidatorImpl
chat chat.API
}
func NewChatHandler(r router.Router, provider jwtprovider.Provider, v *validator.ValidatorImpl, api chat.API) Handler {
return &ChatHandler{
router: r,
provider: provider,
validator: v,
chat: api,
}
}
func (h *ChatHandler) RegisterRoutes() {
h.router.Private(http.MethodPost, "/api/v1/chats", h.Create)
h.router.Private(http.MethodGet, "/api/v1/chats", h.Get)
h.router.Private(http.MethodGet, "/api/v1/chats/{chat_id}", h.GetByID)
h.router.Private(http.MethodPost, "/api/v1/chats/{chat_id}/messages", h.SendMessage)
h.router.Private(http.MethodGet, "/api/v1/chats/{chat_id}/messages", h.GetMessages)
}
func (h *ChatHandler) Create(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
userData, err := framework.ParseToken(r, h.provider)
if err != nil {
framework.JSONError(ctx, w, err)
return
}
var req contracts.CreateChat
if !framework.Decode(w, r, &req) || !framework.Validate(w, r, h.validator, &req) {
return
}
if userData.UserID == uuid.Nil ||
!validText(req.Title, 100) ||
len(req.MemberIds) < 1 ||
len(req.MemberIds) > 100 {
framework.JSONError(ctx, w, apperr.New(apperr.CodeBadRequest, "invalid chat fields"))
return
}
resp, err := h.chat.CreateChat(ctx, dto.CreateChat{
CreatorID: userData.UserID,
Title: req.Title,
MemberIDs: req.MemberIds,
})
if err != nil {
framework.JSONError(ctx, w, err)
return
}
framework.JSONResponse(w, http.StatusCreated, contracts.Chat{
Id: resp.ID,
Title: resp.Title,
MemberIds: resp.MemberIDs,
CreatedAt: resp.CreatedAt,
})
}
func (h *ChatHandler) Get(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
userData, err := framework.ParseToken(r, h.provider)
if err != nil {
framework.JSONError(ctx, w, err)
return
}
limit, afterID, ok := framework.PageParams(w, r)
if !ok {
return
}
if userData.UserID == uuid.Nil {
framework.JSONError(ctx, w, apperr.New(apperr.CodeBadRequest, "invalid user id"))
return
}
if afterID != nil && *afterID == uuid.Nil {
framework.JSONError(ctx, w, apperr.New(apperr.CodeBadRequest, "invalid cursor"))
return
}
page, err := h.chat.ListForMember(ctx, dto.ChatFilters{
UserID: userData.UserID,
Limit: limit,
AfterID: afterID,
})
if err != nil {
framework.JSONError(ctx, w, err)
return
}
items := make([]contracts.Chat, 0, len(page.Items))
for _, item := range page.Items {
items = append(items, contracts.Chat{
CreatedAt: item.CreatedAt,
Id: item.ID,
MemberIds: item.MemberIDs,
Title: item.Title,
})
}
framework.JSONResponse(w, http.StatusOK, contracts.ChatPage{
Items: items,
NextCursor: cursorString(page.NextCursorID),
})
}
func (h *ChatHandler) GetByID(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
userData, err := framework.ParseToken(r, h.provider)
if err != nil {
framework.JSONError(ctx, w, err)
return
}
chatID, err := framework.ParseIDFromPathParam(ctx, w, r, "chat_id")
if err != nil {
return
}
resp, err := h.chat.GetForMember(ctx, dto.ChatMember{
UserID: userData.UserID,
ChatID: chatID,
})
if err != nil {
framework.JSONError(ctx, w, err)
return
}
framework.JSONResponse(w, http.StatusOK, contracts.Chat{
CreatedAt: resp.CreatedAt,
Id: resp.ID,
MemberIds: resp.MemberIDs,
Title: resp.Title,
})
}
func (h *ChatHandler) SendMessage(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
userData, err := framework.ParseToken(r, h.provider)
if err != nil {
framework.JSONError(ctx, w, err)
return
}
chatID, err := framework.ParseIDFromPathParam(ctx, w, r, "chat_id")
if err != nil {
return
}
var req contracts.CreateMessage
if !framework.Decode(w, r, &req) || !framework.Validate(w, r, h.validator, &req) {
return
}
if !validText(req.Text, 4000) {
framework.JSONError(ctx, w, apperr.New(apperr.CodeBadRequest, "invalid message text"))
return
}
message, err := h.chat.CreateMessage(ctx, dto.CreateMessage{
ChatID: chatID,
SenderID: userData.UserID,
Text: req.Text,
})
if err != nil {
framework.JSONError(ctx, w, err)
return
}
framework.JSONResponse(w, http.StatusCreated, contracts.Message{
Id: message.ID,
ChatId: message.ChatID,
SenderId: message.SenderID,
Text: message.Text,
CreatedAt: message.CreatedAt,
})
}
func (h *ChatHandler) GetMessages(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
userData, err := framework.ParseToken(r, h.provider)
if err != nil {
framework.JSONError(ctx, w, err)
return
}
chatID, err := framework.ParseIDFromPathParam(ctx, w, r, "chat_id")
if err != nil {
return
}
limit, afterID, ok := framework.PageParams(w, r)
if !ok {
return
}
page, err := h.chat.ListForChat(ctx, dto.MessageFilters{
ChatID: chatID,
UserID: userData.UserID,
Limit: limit,
AfterID: afterID,
})
if err != nil {
framework.JSONError(ctx, w, err)
return
}
items := make([]contracts.Message, 0, len(page.Items))
for _, message := range page.Items {
items = append(items, contracts.Message{
Id: message.ID,
ChatId: message.ChatID,
SenderId: message.SenderID,
Text: message.Text,
CreatedAt: message.CreatedAt,
})
}
framework.JSONResponse(w, http.StatusOK, contracts.MessagePage{Items: items, NextCursor: cursorString(page.NextCursorID)})
}
func cursorString(id *uuid.UUID) *string {
if id == nil {
return nil
}
value := id.String()
return &value
}
func validText(value string, maxLength int) bool {
return utf8.ValidString(value) && strings.TrimSpace(value) != "" && utf8.RuneCountInString(value) <= maxLength
}
@@ -0,0 +1,101 @@
package http
import (
"context"
"errors"
"log/slog"
"net"
"net/http"
"sync/atomic"
"gitea.privcloud.tech/mtusi2026/internal/config"
"gitea.privcloud.tech/mtusi2026/internal/pkg/rest/router"
)
type Server interface {
ShouldBeRunning() bool
Ready() bool
Start(ctx context.Context) error
Stop(ctx context.Context) error
}
type server struct {
server http.Server
cfg *config.Server
ready atomic.Bool
}
func New(cfg *config.Config, router router.Router) Server {
s := server{
server: http.Server{
Addr: cfg.Server.BindAddress(),
Handler: router,
ReadTimeout: cfg.Server.ReadTimeout,
WriteTimeout: cfg.Server.WriteTimeout,
IdleTimeout: cfg.Server.IdleTimeout,
},
cfg: cfg.Server,
ready: atomic.Bool{},
}
if err := s.validate(); err != nil {
panic(err)
}
return &s
}
func (s *server) Start(_ context.Context) error {
if !s.ShouldBeRunning() {
slog.Info("server should not be running: skip starting")
return nil
}
listener, err := net.Listen("tcp", s.server.Addr)
if err != nil {
return err
}
s.ready.Store(true)
go func() {
defer s.ready.Store(false)
if err := s.server.Serve(listener); err != nil &&
!errors.Is(err, http.ErrServerClosed) {
slog.Error("rest server failed", "error", err)
}
}()
return nil
}
func (s *server) Stop(ctx context.Context) error {
if !s.ShouldBeRunning() {
slog.Info("server should not be running: skip stopping")
return nil
}
slog.Info("shutting down rest server...", "address", s.server.Addr)
s.ready.Store(false)
if err := s.server.Shutdown(ctx); err != nil {
slog.Error("rest server shutdown failed", "error", err)
return err
}
slog.Info("rest server shutdown successfully")
return nil
}
func (s *server) ShouldBeRunning() bool {
return s.cfg.Enabled
}
func (s *server) Ready() bool {
return s.ready.Load()
}
func (s *server) validate() error {
if s.cfg == nil {
slog.Error("failed to validate server: provided nil config")
return errors.New("failed to validate server: provided nil config")
}
slog.Info("server successfully validated")
return nil
}
@@ -0,0 +1,5 @@
package http
type Handler interface {
RegisterRoutes()
}
@@ -0,0 +1,51 @@
package http
import (
"context"
"net/http"
"time"
"gitea.privcloud.tech/mtusi2026/internal/gen/contracts"
"gitea.privcloud.tech/mtusi2026/internal/pkg/apperr"
"gitea.privcloud.tech/mtusi2026/internal/pkg/rest/framework"
"gitea.privcloud.tech/mtusi2026/internal/pkg/rest/router"
)
type databasePinger interface{ Ping(context.Context) error }
type HealthHandler struct {
router router.Router
server Server
database databasePinger
}
func NewHealthHandler(r router.Router, server Server, database databasePinger) Handler {
return &HealthHandler{
router: r,
server: server,
database: database,
}
}
func (h *HealthHandler) RegisterRoutes() {
h.router.Public(http.MethodGet, "/health/ready", h.Ready)
h.router.Public(http.MethodGet, "/health/live", h.Live)
}
func (h *HealthHandler) Live(w http.ResponseWriter, _ *http.Request) {
framework.JSONResponse(w, http.StatusOK, contracts.Health{Status: contracts.Ok})
}
func (h *HealthHandler) Ready(w http.ResponseWriter, r *http.Request) {
if !h.server.Ready() {
framework.JSONError(r.Context(), w, apperr.New(apperr.CodeUnavailable, "server is not ready"))
return
}
ctx, cancel := context.WithTimeout(r.Context(), 200*time.Millisecond)
defer cancel()
if err := h.database.Ping(ctx); err != nil {
framework.JSONError(r.Context(), w, apperr.New(apperr.CodeUnavailable, "database unavailable"))
return
}
framework.JSONResponse(w, http.StatusOK, contracts.Health{Status: contracts.Ok})
}
@@ -0,0 +1 @@
package http
@@ -0,0 +1,113 @@
package http
import (
"net/http"
"regexp"
"strings"
"unicode/utf8"
"github.com/google/uuid"
"gitea.privcloud.tech/mtusi2026/internal/dto"
"gitea.privcloud.tech/mtusi2026/internal/gen/contracts"
"gitea.privcloud.tech/mtusi2026/internal/pkg/apperr"
"gitea.privcloud.tech/mtusi2026/internal/pkg/auth/jwtprovider"
"gitea.privcloud.tech/mtusi2026/internal/pkg/rest/framework"
"gitea.privcloud.tech/mtusi2026/internal/pkg/rest/router"
"gitea.privcloud.tech/mtusi2026/internal/pkg/validator"
"gitea.privcloud.tech/mtusi2026/internal/service/user"
)
type UserHandler struct {
router router.Router
provider jwtprovider.Provider
validator *validator.ValidatorImpl
user user.API
}
func NewUserHandler(r router.Router, provider jwtprovider.Provider, v *validator.ValidatorImpl, api user.API) Handler {
return &UserHandler{
router: r,
provider: provider,
validator: v,
user: api,
}
}
var usernamePattern = regexp.MustCompile(`^[a-z0-9_]{3,32}$`)
func (h *UserHandler) RegisterRoutes() {
h.router.Public(http.MethodPost, "/api/v1/users", h.Create)
h.router.Private(http.MethodGet, "/api/v1/users/me", h.GetMe)
}
func (h *UserHandler) Create(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
var req contracts.CreateUser
if !framework.Decode(w, r, &req) || !framework.Validate(w, r, h.validator, &req) {
return
}
toCreate := dto.CreateUser{
Username: req.Username,
DisplayName: req.DisplayName,
}
if req.Password != nil {
toCreate.Password = *req.Password
}
if !usernamePattern.MatchString(req.Username) || !utf8.ValidString(req.DisplayName) ||
strings.TrimSpace(req.DisplayName) == "" || utf8.RuneCountInString(req.DisplayName) > 100 {
framework.JSONError(ctx, w, apperr.New(apperr.CodeBadRequest, "invalid user fields"))
return
}
passwordLen := utf8.RuneCountInString(toCreate.Password)
if !utf8.ValidString(toCreate.Password) || strings.TrimSpace(toCreate.Password) == "" || passwordLen < 12 || passwordLen > 128 {
framework.JSONError(ctx, w, apperr.New(apperr.CodeBadRequest, "invalid password"))
return
}
resp, err := h.user.Create(ctx, toCreate)
if err != nil {
framework.JSONError(ctx, w, err)
return
}
framework.JSONResponse(w, http.StatusCreated, contracts.User{
CreatedAt: resp.CreatedAt,
DisplayName: resp.DisplayName,
Id: resp.ID,
Username: resp.Username,
})
}
func (h *UserHandler) GetMe(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
userData, err := framework.ParseToken(r, h.provider)
if err != nil {
framework.JSONError(ctx, w, err)
return
}
if userData.UserID == uuid.Nil {
framework.JSONError(ctx, w, apperr.New(apperr.CodeBadRequest, "invalid user id"))
return
}
resp, err := h.user.GetByID(ctx, userData.UserID)
if err != nil {
framework.JSONError(ctx, w, err)
return
}
framework.JSONResponse(w, http.StatusOK, contracts.User{
CreatedAt: resp.CreatedAt,
DisplayName: resp.DisplayName,
Id: resp.ID,
Username: resp.Username,
})
}
@@ -0,0 +1,107 @@
package inmemory
import (
"log/slog"
"sync/atomic"
"unsafe"
)
type Cache[K comparable, V any] interface {
Name() string
GetAll() map[K]V
GetList() []V
Get(key K) (value V, ok bool)
Find(predicate func(K, V) bool) []V
}
type CopyAndWriteCache[K comparable, V any] struct {
name string
data unsafe.Pointer
}
func NewCopyAndWriteCache[K comparable, V any](
name string,
) *CopyAndWriteCache[K, V] {
c := CopyAndWriteCache[K, V]{
name: name,
}
emptyMap := make(map[K]V)
atomic.StorePointer(&c.data, unsafe.Pointer(&emptyMap))
slog.Info("cache initialized", "name", name)
return &c
}
func (c *CopyAndWriteCache[K, V]) Name() string {
return c.name
}
func (c *CopyAndWriteCache[K, V]) GetAll() map[K]V {
ptr := atomic.LoadPointer(&c.data)
if ptr == nil {
return make(map[K]V)
}
m := *(*map[K]V)(ptr)
out := make(map[K]V, len(m))
for k, v := range m {
out[k] = v
}
return out
}
func (c *CopyAndWriteCache[K, V]) GetList() []V {
records := c.GetAll()
out := make([]V, 0, len(records))
for _, record := range records {
out = append(out, record)
}
return out
}
func (c *CopyAndWriteCache[K, V]) Get(key K) (value V, ok bool) {
ptr := atomic.LoadPointer(&c.data)
if ptr == nil {
var zero V
return zero, false
}
m := *(*map[K]V)(ptr)
v, ok := m[key]
return v, ok
}
func (c *CopyAndWriteCache[K, V]) Find(predicate func(K, V) bool) []V {
ptr := atomic.LoadPointer(&c.data)
if ptr == nil {
return []V{}
}
m := *(*map[K]V)(ptr)
var result []V
for key, value := range m {
if predicate(key, value) {
result = append(result, value)
}
}
return result
}
func (c *CopyAndWriteCache[K, V]) Store(key K, value V) bool {
ptr := atomic.LoadPointer(&c.data)
if ptr == nil {
return false
}
m := *(*map[K]V)(ptr)
m[key] = value
return true
}
@@ -0,0 +1,78 @@
package outside
import (
"context"
"encoding/json"
"fmt"
"time"
"github.com/google/uuid"
"gitea.privcloud.tech/mtusi2026/internal/dto"
"gitea.privcloud.tech/mtusi2026/internal/pkg/apperr"
"gitea.privcloud.tech/mtusi2026/internal/pkg/cache"
)
const (
// chatRedisKey equals "chat:{chat_id}" path
chatRedisKey = "chat:%s"
)
type ChatCache struct {
client *cache.Client
}
func NewChatCache(client *cache.Client) *ChatCache {
return &ChatCache{
client: client,
}
}
type chat struct {
ID uuid.UUID `json:"id"`
Title string `json:"title"`
MemberIDs []uuid.UUID `json:"member_ids"`
CreatedAt time.Time `json:"created_at"`
}
func (r *ChatCache) Create(ctx context.Context, req dto.Chat) error {
data, err := json.Marshal(chat{
ID: req.ID,
Title: req.Title,
MemberIDs: req.MemberIDs,
CreatedAt: req.CreatedAt,
})
if err != nil {
return apperr.Wrap(err, apperr.CodeInternal, "failed to marshal chat cache")
}
ctx, cancel := context.WithTimeout(ctx, cache.OperationTimeout)
defer cancel()
err = r.client.Set(ctx, fmt.Sprintf(chatRedisKey, req.ID), data, 0).Err()
if err != nil {
return apperr.WrapRedis(err, "failed to create chat cache")
}
return nil
}
func (r *ChatCache) Get(ctx context.Context, chatID uuid.UUID) (*dto.Chat, error) {
ctx, cancel := context.WithTimeout(ctx, cache.OperationTimeout)
defer cancel()
data, err := r.client.Get(ctx, fmt.Sprintf(chatRedisKey, chatID.String())).Bytes()
if err != nil {
return nil, apperr.WrapRedis(err, "failed to read chat cache")
}
var item chat
if err = json.Unmarshal(data, &item); err != nil {
return nil, apperr.Wrap(err, apperr.CodeInternal, "failed to unmarshal chat cache")
}
return &dto.Chat{
ID: item.ID,
Title: item.Title,
MemberIDs: item.MemberIDs,
CreatedAt: item.CreatedAt,
}, nil
}
@@ -0,0 +1,91 @@
package storage
import (
"context"
"errors"
"github.com/google/uuid"
"github.com/jackc/pgerrcode"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
"github.com/jackc/pgx/v5/pgxpool"
"gitea.privcloud.tech/mtusi2026/internal/dto"
"gitea.privcloud.tech/mtusi2026/internal/pkg/apperr"
)
type ChatsRepo struct {
pool *pgxpool.Pool
}
func NewChatsRepo(pool *pgxpool.Pool) *ChatsRepo {
return &ChatsRepo{pool: pool}
}
func (r *ChatsRepo) CreateTx(ctx context.Context, tx pgx.Tx, req dto.Chat) error {
const insertChat = `INSERT INTO chats (id, title, created_at) VALUES ($1, $2, $3)`
if _, err := tx.Exec(ctx, insertChat, req.ID, req.Title, req.CreatedAt); err != nil {
return apperr.WrapPostgres(err, "failed to create chat")
}
const insertMembers = `INSERT INTO chat_members (chat_id, user_id)
SELECT $1, user_id FROM unnest($2::uuid[]) AS members(user_id)`
if _, err := tx.Exec(ctx, insertMembers, req.ID, req.MemberIDs); err != nil {
if pgErr, ok := errors.AsType[*pgconn.PgError](err); ok &&
pgErr.Code == pgerrcode.ForeignKeyViolation && pgErr.ConstraintName == "chat_members_user_fk" {
return apperr.Wrap(err, apperr.CodeBadRequest, "unknown chat member")
}
return apperr.WrapPostgres(err, "failed to create chat members")
}
return nil
}
func (r *ChatsRepo) GetForMember(ctx context.Context, req dto.ChatMember) (*dto.Chat, error) {
const query = `SELECT c.id, c.title, c.created_at,
ARRAY(SELECT m.user_id FROM chat_members m WHERE m.chat_id = c.id ORDER BY m.user_id)
FROM chats c
WHERE c.id = $1
AND EXISTS (SELECT 1 FROM chat_members access WHERE access.chat_id = c.id AND access.user_id = $2)`
return scanChat(r.pool.QueryRow(ctx, query, req.ChatID, req.UserID))
}
func (r *ChatsRepo) ListForMember(ctx context.Context, userID uuid.UUID, page dto.PageQuery) ([]dto.Chat, error) {
query := `WITH page AS MATERIALIZED (
SELECT c.id, c.title, c.created_at
FROM chats c JOIN chat_members access ON access.chat_id = c.id
WHERE access.user_id = $1`
args := []any{userID, page.Limit}
if page.After != nil {
query += ` AND (c.created_at, c.id) > ($3, $4)`
args = append(args, page.After.CreatedAt, page.After.ID)
}
query += ` ORDER BY c.created_at, c.id LIMIT $2
)
SELECT p.id, p.title, p.created_at,
ARRAY(SELECT m.user_id FROM chat_members m WHERE m.chat_id = p.id ORDER BY m.user_id)
FROM page p ORDER BY p.created_at, p.id`
rows, err := r.pool.Query(ctx, query, args...)
if err != nil {
return nil, apperr.WrapPostgres(err, "failed to list chats")
}
defer rows.Close()
chats := make([]dto.Chat, 0)
for rows.Next() {
chat, err := scanChat(rows)
if err != nil {
return nil, err
}
chats = append(chats, *chat)
}
if err = rows.Err(); err != nil {
return nil, apperr.WrapPostgres(err, "failed to list chats")
}
return chats, nil
}
func scanChat(row pgx.Row) (*dto.Chat, error) {
var chat dto.Chat
if err := row.Scan(&chat.ID, &chat.Title, &chat.CreatedAt, &chat.MemberIDs); err != nil {
return nil, apperr.WrapPostgres(err, "failed to get chat")
}
return &chat, nil
}
@@ -0,0 +1,75 @@
package storage
import (
"context"
"errors"
"github.com/google/uuid"
"github.com/jackc/pgerrcode"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
"github.com/jackc/pgx/v5/pgxpool"
"gitea.privcloud.tech/mtusi2026/internal/dto"
"gitea.privcloud.tech/mtusi2026/internal/pkg/apperr"
)
type MessagesRepo struct {
pool *pgxpool.Pool
}
func NewMessagesRepo(pool *pgxpool.Pool) *MessagesRepo {
return &MessagesRepo{pool: pool}
}
func (r *MessagesRepo) Create(ctx context.Context, req dto.Message) error {
const query = `INSERT INTO messages (id, chat_id, sender_id, text, created_at) VALUES ($1, $2, $3, $4, $5)`
if _, err := r.pool.Exec(ctx, query, req.ID, req.ChatID, req.SenderID, req.Text, req.CreatedAt); err != nil {
if pgErr, ok := errors.AsType[*pgconn.PgError](err); ok &&
pgErr.Code == pgerrcode.ForeignKeyViolation && pgErr.ConstraintName == "messages_sender_member_fk" {
return apperr.Wrap(err, apperr.CodeNotFound, "chat not found")
}
return apperr.WrapPostgres(err, "failed to create message")
}
return nil
}
func (r *MessagesRepo) GetByIDForChat(ctx context.Context, chatID, messageID uuid.UUID) (*dto.Message, error) {
const query = `SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = $1 AND id = $2`
return scanMessage(r.pool.QueryRow(ctx, query, chatID, messageID))
}
func (r *MessagesRepo) ListForChat(ctx context.Context, chatID uuid.UUID, page dto.PageQuery) ([]dto.Message, error) {
query := `SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = $1`
args := []any{chatID, page.Limit}
if page.After != nil {
query += ` AND (created_at, id) > ($3, $4)`
args = append(args, page.After.CreatedAt, page.After.ID)
}
query += ` ORDER BY created_at, id LIMIT $2`
rows, err := r.pool.Query(ctx, query, args...)
if err != nil {
return nil, apperr.WrapPostgres(err, "failed to list messages")
}
defer rows.Close()
messages := make([]dto.Message, 0)
for rows.Next() {
message, err := scanMessage(rows)
if err != nil {
return nil, err
}
messages = append(messages, *message)
}
if err = rows.Err(); err != nil {
return nil, apperr.WrapPostgres(err, "failed to list messages")
}
return messages, nil
}
func scanMessage(row pgx.Row) (*dto.Message, error) {
var message dto.Message
if err := row.Scan(&message.ID, &message.ChatID, &message.SenderID, &message.Text, &message.CreatedAt); err != nil {
return nil, apperr.WrapPostgres(err, "failed to get message")
}
return &message, nil
}
@@ -0,0 +1,193 @@
package storage
import (
"context"
"time"
"github.com/google/uuid"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgxpool"
"gitea.privcloud.tech/mtusi2026/internal/dto"
"gitea.privcloud.tech/mtusi2026/internal/pkg/apperr"
"gitea.privcloud.tech/mtusi2026/internal/pkg/postgres"
)
type RefreshTokensRepo struct {
pool *pgxpool.Pool
}
func NewRefreshTokensRepo(pool *pgxpool.Pool) *RefreshTokensRepo {
return &RefreshTokensRepo{
pool: pool,
}
}
func (r *RefreshTokensRepo) Create(ctx context.Context, req dto.StoredRefreshToken) error {
return r.create(ctx, r.pool, req)
}
func (r *RefreshTokensRepo) CreateTx(ctx context.Context, tx pgx.Tx, req dto.StoredRefreshToken) error {
return r.create(ctx, tx, req)
}
func (r *RefreshTokensRepo) GetByID(ctx context.Context, id uuid.UUID) (*dto.StoredRefreshToken, error) {
return r.getByID(ctx, r.pool, id, false)
}
func (r *RefreshTokensRepo) GetByIDTx(ctx context.Context, tx pgx.Tx, id uuid.UUID) (*dto.StoredRefreshToken, error) {
return r.getByID(ctx, tx, id, false)
}
func (r *RefreshTokensRepo) GetByIDForUpdate(ctx context.Context, id uuid.UUID) (*dto.StoredRefreshToken, error) {
return r.getByID(ctx, r.pool, id, true)
}
func (r *RefreshTokensRepo) GetByIDForUpdateTx(ctx context.Context, tx pgx.Tx, id uuid.UUID) (*dto.StoredRefreshToken, error) {
return r.getByID(ctx, tx, id, true)
}
func (r *RefreshTokensRepo) Revoke(ctx context.Context, req dto.RevokeRefreshToken) error {
return r.revoke(ctx, r.pool, req)
}
func (r *RefreshTokensRepo) RevokeTx(ctx context.Context, tx pgx.Tx, req dto.RevokeRefreshToken) error {
return r.revoke(ctx, tx, req)
}
func (r *RefreshTokensRepo) RevokeAllByUserID(ctx context.Context, req dto.RevokeRefreshTokensByUserID) error {
return r.revokeAllByUserID(ctx, r.pool, req)
}
func (r *RefreshTokensRepo) RevokeAllByUserIDTx(ctx context.Context, tx pgx.Tx, req dto.RevokeRefreshTokensByUserID) error {
return r.revokeAllByUserID(ctx, tx, req)
}
func (r *RefreshTokensRepo) DeleteExpired(ctx context.Context) error {
const query = `
DELETE FROM refresh_tokens
WHERE expires_at < $1`
_, err := r.pool.Exec(ctx, query, time.Now())
if err != nil {
return apperr.WrapPostgres(err, "failed to delete expired refresh tokens")
}
return nil
}
func (r *RefreshTokensRepo) create(ctx context.Context, conn postgres.Conn, req dto.StoredRefreshToken) error {
const query = `INSERT INTO refresh_tokens (id,
user_id,
token_hash,
user_agent,
ip_address,
role,
expires_at,
created_at)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8)`
ct, err := conn.Exec(
ctx,
query,
req.ID,
req.UserID,
req.TokenHash,
req.UserAgent,
req.IPAddress,
req.Role,
req.ExpiresAt,
req.CreatedAt,
)
if err != nil {
return apperr.WrapPostgres(err, "failed to create refresh token")
}
if ct.RowsAffected() == 0 {
return apperr.New(apperr.CodeAlreadyExists, "refresh token already exists")
}
return nil
}
func (r *RefreshTokensRepo) getByID(ctx context.Context, conn postgres.Conn, id uuid.UUID, lock bool) (*dto.StoredRefreshToken, error) {
const query = `SELECT id,
user_id,
token_hash,
user_agent,
ip_address,
role,
expires_at,
revoked_at,
created_at
FROM refresh_tokens
WHERE id = $1`
const queryLock = `SELECT id,
user_id,
token_hash,
user_agent,
ip_address,
role,
expires_at,
revoked_at,
created_at
FROM refresh_tokens
WHERE id = $1 FOR UPDATE`
use := query
if lock {
use = queryLock
}
var token dto.StoredRefreshToken
err := conn.QueryRow(ctx, use, id).Scan(
&token.ID,
&token.UserID,
&token.TokenHash,
&token.UserAgent,
&token.IPAddress,
&token.Role,
&token.ExpiresAt,
&token.RevokedAt,
&token.CreatedAt,
)
if err != nil {
return nil, apperr.WrapPostgres(err, "failed to get refresh by id")
}
return &token, nil
}
func (r *RefreshTokensRepo) revoke(ctx context.Context, conn postgres.Conn, req dto.RevokeRefreshToken) error {
const query = `
UPDATE refresh_tokens
SET revoked_at = $2
WHERE id = $1
AND revoked_at IS NULL`
ct, err := conn.Exec(ctx, query, req.ID, req.RevokedAt)
if err != nil {
return apperr.WrapPostgres(err, "failed to revoke refresh token")
}
if ct.RowsAffected() == 0 {
return apperr.New(apperr.CodeNotFound, "refresh token not found")
}
return nil
}
func (r *RefreshTokensRepo) revokeAllByUserID(ctx context.Context, conn postgres.Conn, req dto.RevokeRefreshTokensByUserID) error {
const query = `
UPDATE refresh_tokens
SET revoked_at = $2
WHERE user_id = $1
AND revoked_at IS NULL`
_, err := conn.Exec(ctx, query, req.UserID, req.RevokedAt)
if err != nil {
return apperr.WrapPostgres(err, "failed to revoke refresh tokens")
}
return nil
}
@@ -0,0 +1,103 @@
package storage
import (
"context"
"errors"
"github.com/google/uuid"
"github.com/jackc/pgerrcode"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
"github.com/jackc/pgx/v5/pgxpool"
"gitea.privcloud.tech/mtusi2026/internal/dto"
"gitea.privcloud.tech/mtusi2026/internal/pkg/apperr"
"gitea.privcloud.tech/mtusi2026/internal/pkg/postgres"
)
type UsersRepo struct {
pool *pgxpool.Pool
}
func NewUsersRepo(pool *pgxpool.Pool) *UsersRepo {
return &UsersRepo{pool: pool}
}
func (r *UsersRepo) Create(ctx context.Context, req dto.CreateStoredUser) error {
return r.create(ctx, r.pool, req)
}
func (r *UsersRepo) CreateTx(ctx context.Context, tx pgx.Tx, req dto.CreateStoredUser) error {
return r.create(ctx, tx, req)
}
func (r *UsersRepo) GetByID(ctx context.Context, id uuid.UUID) (*dto.User, error) {
return r.getByID(ctx, r.pool, id)
}
func (r *UsersRepo) GetByIDTx(ctx context.Context, tx pgx.Tx, id uuid.UUID) (*dto.User, error) {
return r.getByID(ctx, tx, id)
}
func (r *UsersRepo) GetByUsername(ctx context.Context, username string) (*dto.User, error) {
const query = `SELECT id, username, name, created_at FROM users WHERE username = $1`
return scanUser(r.pool.QueryRow(ctx, query, username))
}
func (r *UsersRepo) GetCredentialsByUsername(ctx context.Context, username string) (*dto.UserCredentials, error) {
const query = `SELECT id, username, name, created_at, password_hash FROM users WHERE username = $1`
var credentials dto.UserCredentials
err := r.pool.QueryRow(ctx, query, username).Scan(
&credentials.User.ID,
&credentials.User.Username,
&credentials.User.DisplayName,
&credentials.User.CreatedAt,
&credentials.PasswordHash,
)
if err != nil {
return nil, apperr.WrapPostgres(err, "failed to get user credentials")
}
return &credentials, nil
}
func (r *UsersRepo) Delete(ctx context.Context, id uuid.UUID) error {
const query = `DELETE FROM users WHERE id = $1`
ct, err := r.pool.Exec(ctx, query, id)
if err != nil {
return apperr.WrapPostgres(err, "failed to delete user")
}
if ct.RowsAffected() == 0 {
return apperr.New(apperr.CodeNotFound, "user not found")
}
return nil
}
func (r *UsersRepo) create(ctx context.Context, conn postgres.Conn, req dto.CreateStoredUser) error {
const query = `INSERT INTO users (id, username, name, password_hash, created_at, updated_at)
VALUES ($1, $2, $3, $4, $5, $6)`
_, err := conn.Exec(ctx, query, req.ID, req.Username, req.DisplayName, req.PasswordHash, req.CreatedAt, req.UpdatedAt)
if err != nil {
if pgErr, ok := errors.AsType[*pgconn.PgError](err); ok &&
pgErr.Code == pgerrcode.UniqueViolation && pgErr.ConstraintName == "users_username_unique" {
return apperr.Wrap(err, apperr.CodeConflict, "username already exists")
}
return apperr.WrapPostgres(err, "failed to create user")
}
return nil
}
func (r *UsersRepo) getByID(ctx context.Context, conn postgres.Conn, id uuid.UUID) (*dto.User, error) {
const query = `SELECT id, username, name, created_at FROM users WHERE id = $1`
return scanUser(conn.QueryRow(ctx, query, id))
}
func scanUser(row pgx.Row) (*dto.User, error) {
var user dto.User
if err := row.Scan(&user.ID, &user.Username, &user.DisplayName, &user.CreatedAt); err != nil {
return nil, apperr.WrapPostgres(err, "failed to get user")
}
return &user, nil
}
+7
View File
@@ -0,0 +1,7 @@
package config
import "github.com/spf13/viper"
type Loader interface {
loadConfig(v *viper.Viper) error
}
+63
View File
@@ -0,0 +1,63 @@
package config
import (
"errors"
"time"
"github.com/spf13/viper"
"gitea.privcloud.tech/mtusi2026/internal/pkg/types/environment"
)
type Application struct {
LogLevel string
ShutdownTimeout time.Duration
Environment environment.ApplicationEnvironment
RequestRateLimit float64
BurstRateLimit int
RateLimitTTL time.Duration
}
func (c *Application) Validate() error {
environmentErr := c.Environment.Validate()
switch {
case c.LogLevel == "":
return wrapValidationError("application", errors.New("log_level cannot be empty in application config"))
case c.ShutdownTimeout == 0:
return wrapValidationError("application", errors.New("shutdown_timeout cannot be zero in application config"))
case environmentErr != nil:
return wrapValidationError("application", environmentErr)
//case c.RequestRateLimit == 0:
// return wrapValidationError("application", errors.New("request_rate_limit cannot be zero in application config"))
//case c.BurstRateLimit == 0:
// return wrapValidationError("application", errors.New("burst_rate_limit cannot be zero in application config"))
//case c.RateLimitTTL == 0:
// return wrapValidationError("application", errors.New("rate_limit_ttl cannot be zero in application config"))
default:
return nil
}
}
func (c *Application) loadConfig(v *viper.Viper) error {
v.SetEnvPrefix("APPLICATION")
c.LogLevel = v.GetString("LOG_LEVEL")
c.ShutdownTimeout = v.GetDuration("SHUTDOWN_TIMEOUT")
c.Environment = environment.ParseEnvironment(v.GetString("ENVIRONMENT"))
// todo add cool value
c.RequestRateLimit = v.GetFloat64("REQUEST_RATE_LIMIT")
c.BurstRateLimit = v.GetInt("BURST_RATE_LIMIT")
c.RateLimitTTL = v.GetDuration("RATE_LIMIT_TTL")
return nil
}
func (c *Application) copy() *Application {
return &Application{
LogLevel: c.LogLevel,
ShutdownTimeout: c.ShutdownTimeout,
Environment: c.Environment,
RequestRateLimit: c.RequestRateLimit,
BurstRateLimit: c.BurstRateLimit,
RateLimitTTL: c.RateLimitTTL,
}
}
+110
View File
@@ -0,0 +1,110 @@
package config
import (
"strings"
"time"
"github.com/spf13/viper"
"go.uber.org/multierr"
"gitea.privcloud.tech/mtusi2026/internal/pkg/types/environment"
)
var defaultConfig = &Config{
Server: &Server{
Host: "localhost",
Port: 8001,
ReadTimeout: 10 * time.Second,
WriteTimeout: 10 * time.Second,
IdleTimeout: 10 * time.Second,
ShutdownTimeout: 10 * time.Second,
Enabled: false,
},
Postgres: &Postgres{
Host: "localhost",
Port: 5432,
User: "postgres",
Password: "postgres",
Database: "postgres",
VersionTable: "versions",
RunMigrations: false,
MaxConnections: 10,
ConnectTimeout: 500 * time.Millisecond,
QueryTimeout: 2 * time.Second,
},
Redis: &Redis{
Host: "localhost",
Port: 6379,
Username: "",
Password: "",
DB: 0,
},
JWT: &JWT{
AccessTokenLifetime: 4 * time.Hour,
RefreshTokenLifetime: time.Hour,
PublicKeyPath: "certs/private.pem",
PrivateKeyPath: "certs/public.pem",
},
Application: &Application{
LogLevel: "info",
ShutdownTimeout: 10 * time.Second,
Environment: environment.ApplicationEnvironmentDev,
RequestRateLimit: 100,
},
}
type Config struct {
Server *Server
Postgres *Postgres
Redis *Redis
JWT *JWT
Application *Application
}
func New() (*Config, error) {
v := viper.New()
v.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
v.AutomaticEnv()
cfg := defaultConfig.copy()
if err := cfg.loadConfig(v); err != nil {
return nil, err
}
if err := cfg.Validate(); err != nil {
return nil, err
}
return cfg, nil
}
func (c *Config) Validate() error {
return multierr.Combine(
c.Server.Validate(),
c.Postgres.Validate(),
c.JWT.Validate(),
c.Redis.Validate(),
c.Application.Validate(),
)
}
func (c *Config) loadConfig(v *viper.Viper) error {
return multierr.Combine(
c.Postgres.loadConfig(v),
c.Server.loadConfig(v),
c.JWT.loadConfig(v),
c.Redis.loadConfig(v),
c.Application.loadConfig(v),
)
}
func (c *Config) copy() *Config {
return &Config{
Server: c.Server.copy(),
Postgres: c.Postgres.copy(),
Redis: c.Redis.copy(),
JWT: c.JWT.copy(),
Application: c.Application.copy(),
}
}
+65
View File
@@ -0,0 +1,65 @@
package config
import (
"errors"
"net/http"
"strings"
"github.com/spf13/viper"
)
type Cookies struct {
Enabled bool
Domain string
Path string
Secure bool
SameSite http.SameSite
AllowedOrigins []string
}
func (c *Cookies) Validate() error {
switch {
case c.Domain == "":
return wrapValidationError("cookies", errors.New("domain cannot be empty"))
case c.Path == "":
return wrapValidationError("cookies", errors.New("path cannot be empty"))
case c.SameSite == http.SameSiteDefaultMode:
return wrapValidationError("cookies", errors.New("same_site_set_to_none_mode cannot be empty"))
//case c.Enabled && !c.Secure:
// return wrapValidationError("cookies", errors.New("if cookies_enabled equals true then cookies_secure must be true"))
case c.AllowedOrigins == nil || len(c.AllowedOrigins) == 0:
return wrapValidationError("cookies", errors.New("allowed_origins cannot be empty"))
default:
return nil
}
}
func (c *Cookies) loadConfig(v *viper.Viper) error {
v.SetEnvPrefix("COOKIES")
c.Enabled = v.GetBool("ENABLED")
c.Domain = v.GetString("DOMAIN")
c.Path = v.GetString("PATH")
c.Secure = v.GetBool("SECURE")
c.AllowedOrigins = v.GetStringSlice("ALLOWED_ORIGINS")
sameSite := v.GetString("SAME_SITE")
switch strings.ToLower(strings.TrimSpace(sameSite)) {
case "strict":
c.SameSite = http.SameSiteStrictMode
case "none":
c.SameSite = http.SameSiteNoneMode
default:
c.SameSite = http.SameSiteLaxMode
}
return nil
}
func (c *Cookies) copy() *Cookies {
return &Cookies{
Enabled: c.Enabled,
Domain: c.Domain,
Path: c.Path,
Secure: c.Secure,
SameSite: c.SameSite,
AllowedOrigins: c.AllowedOrigins,
}
}
+63
View File
@@ -0,0 +1,63 @@
package config
import (
"errors"
"os"
"strconv"
"time"
"github.com/spf13/viper"
)
type JWT struct {
AccessTokenLifetime time.Duration
RefreshTokenLifetime time.Duration
PublicKeyPath string
PrivateKeyPath string
}
func (c *JWT) Validate() error {
switch {
case c.AccessTokenLifetime <= 0:
return wrapValidationError("jwt", errors.New("access_token_lifetime cannot be empty"))
case c.RefreshTokenLifetime <= 0:
return wrapValidationError("jwt", errors.New("refresh_token_lifetime cannot be empty"))
case c.PrivateKeyPath == "":
return wrapValidationError("jwt", errors.New("private_key_path cannot be empty"))
case c.PublicKeyPath == "":
return wrapValidationError("jwt", errors.New("public_key_path cannot be empty"))
default:
return nil
}
}
func (c *JWT) loadConfig(v *viper.Viper) error {
v.SetEnvPrefix("JWT")
c.AccessTokenLifetime = v.GetDuration("ACCESS_TOKEN_LIFETIME")
c.RefreshTokenLifetime = time.Hour
if value := os.Getenv("SESSION_TTL_SECONDS"); value != "" {
seconds, err := strconv.ParseInt(value, 10, 64)
if err != nil || seconds <= 0 || seconds > int64((1<<63-1)/time.Second) {
return wrapValidationError("session", errors.New("SESSION_TTL_SECONDS must be a positive integer duration in seconds"))
}
c.RefreshTokenLifetime = time.Duration(seconds) * time.Second
} else if legacy := v.GetString("REFRESH_TOKEN_LIFETIME"); legacy != "" {
duration, err := time.ParseDuration(legacy)
if err != nil {
return wrapValidationError("jwt", errors.New("invalid refresh_token_lifetime"))
}
c.RefreshTokenLifetime = duration
}
c.PublicKeyPath = v.GetString("PUBLIC_KEY_PATH")
c.PrivateKeyPath = v.GetString("PRIVATE_KEY_PATH")
return nil
}
func (c *JWT) copy() *JWT {
return &JWT{
AccessTokenLifetime: c.AccessTokenLifetime,
RefreshTokenLifetime: c.RefreshTokenLifetime,
PublicKeyPath: c.PublicKeyPath,
PrivateKeyPath: c.PrivateKeyPath,
}
}
+110
View File
@@ -0,0 +1,110 @@
package config
import (
"errors"
"fmt"
"math"
"time"
"github.com/spf13/viper"
)
const (
uri = "postgres://%s:%s@%s:%d/%s?sslmode=disable"
)
type Postgres struct {
Host string
Port int
User string
Password string
Database string
VersionTable string
RunMigrations bool
MaxConnections int
ConnectTimeout time.Duration
QueryTimeout time.Duration
}
func (c *Postgres) Validate() error {
switch {
case c.Host == "":
return wrapValidationError("postgres", errors.New("host cannot be empty"))
case c.Port == 0:
return wrapValidationError("postgres", errors.New("port cannot be empty"))
case c.User == "":
return wrapValidationError("postgres", errors.New("user cannot be empty"))
case c.Password == "":
return wrapValidationError("postgres", errors.New("password cannot be empty"))
case c.Database == "":
return wrapValidationError("postgres", errors.New("database cannot be empty"))
case c.VersionTable == "":
return wrapValidationError("postgres", errors.New("version_table name cannot be empty"))
case c.MaxConnections <= 0 || int64(c.MaxConnections) > math.MaxInt32:
return wrapValidationError("postgres", errors.New("max_connections must be between 1 and 2147483647"))
case c.ConnectTimeout <= 0:
return wrapValidationError("postgres", errors.New("connect_timeout must be positive"))
case c.QueryTimeout < time.Millisecond:
return wrapValidationError("postgres", errors.New("query_timeout must be at least 1ms"))
default:
return nil
}
}
func (c *Postgres) GetMaxConnections() int32 { return int32(c.MaxConnections) }
func (c *Postgres) GetConnectTimeout() time.Duration { return c.ConnectTimeout }
func (c *Postgres) GetQueryTimeout() time.Duration { return c.QueryTimeout }
func (c *Postgres) GetVersionTableName() string {
if c == nil {
return ""
}
return c.VersionTable
}
func (c *Postgres) GetURI() string {
if c == nil {
return ""
}
return fmt.Sprintf(uri, c.User, c.Password, c.Host, c.Port, c.Database)
}
func (c *Postgres) GetRunMigrations() bool {
if c == nil {
return false
}
return c.RunMigrations
}
func (c *Postgres) loadConfig(v *viper.Viper) error {
v.SetEnvPrefix("POSTGRES")
c.Host = v.GetString("HOST")
c.Port = v.GetInt("PORT")
c.User = v.GetString("USER")
c.Password = v.GetString("PASSWORD")
c.Database = v.GetString("DATABASE")
c.VersionTable = v.GetString("VERSION_TABLE")
c.RunMigrations = v.GetBool("RUN_MIGRATIONS")
c.MaxConnections = v.GetInt("MAX_CONNECTIONS")
c.ConnectTimeout = v.GetDuration("CONNECT_TIMEOUT")
c.QueryTimeout = v.GetDuration("QUERY_TIMEOUT")
return nil
}
func (c *Postgres) copy() *Postgres {
if c == nil {
return nil
}
return &Postgres{
Host: c.Host,
Port: c.Port,
User: c.User,
Password: c.Password,
Database: c.Database,
MaxConnections: c.MaxConnections,
ConnectTimeout: c.ConnectTimeout,
QueryTimeout: c.QueryTimeout,
RunMigrations: c.RunMigrations,
VersionTable: c.VersionTable,
}
}
+72
View File
@@ -0,0 +1,72 @@
package config
import (
"errors"
"fmt"
"net"
"time"
"github.com/redis/go-redis/v9"
"github.com/spf13/viper"
)
type Redis struct {
Host string
Port int
Username string
Password string
DB int
}
func (c *Redis) Validate() error {
switch {
case c.Host == "":
return wrapValidationError("redis", errors.New("host cannot be empty"))
case c.Port == 0:
return wrapValidationError("redis", errors.New("port cannot be empty"))
default:
return nil
}
}
func (c *Redis) BuildRedisOptions() *redis.Options {
if c == nil {
return nil
}
return &redis.Options{
Addr: net.JoinHostPort(c.Host, fmt.Sprintf("%d", c.Port)),
Username: c.Username,
Password: c.Password,
DB: c.DB,
DialTimeout: 200 * time.Millisecond,
ReadTimeout: 200 * time.Millisecond,
WriteTimeout: 200 * time.Millisecond,
PoolTimeout: 200 * time.Millisecond,
MaxRetries: -1,
DialerRetries: 1,
ContextTimeoutEnabled: true,
}
}
func (c *Redis) loadConfig(v *viper.Viper) error {
v.SetEnvPrefix("REDIS")
c.Host = v.GetString("HOST")
c.Port = v.GetInt("PORT")
c.DB = v.GetInt("DB")
c.Password = v.GetString("PASSWORD")
c.Username = v.GetString("USERNAME")
return nil
}
func (c *Redis) copy() *Redis {
if c == nil {
return nil
}
return &Redis{
Host: c.Host,
Port: c.Port,
Username: c.Username,
Password: c.Password,
DB: c.DB,
}
}
+69
View File
@@ -0,0 +1,69 @@
package config
import (
"errors"
"fmt"
"time"
"github.com/spf13/viper"
)
type Server struct {
Host string
Port int
ReadTimeout time.Duration
WriteTimeout time.Duration
IdleTimeout time.Duration
ShutdownTimeout time.Duration
Enabled bool
}
func (c *Server) Validate() error {
if !c.Enabled {
return nil
}
switch {
case c.Host == "":
return wrapValidationError("server", errors.New("host cannot be empty"))
case c.Port == 0:
return wrapValidationError("server", errors.New("port cannot be empty"))
case c.ReadTimeout == 0:
return wrapValidationError("server", errors.New("read_timeout cannot be empty"))
case c.WriteTimeout == 0:
return wrapValidationError("server", errors.New("write_timeout cannot be empty"))
case c.IdleTimeout == 0:
return wrapValidationError("server", errors.New("idle_timeout cannot be empty"))
case c.ShutdownTimeout == 0:
return wrapValidationError("server", errors.New("shutdown_timeout name cannot be empty"))
default:
return nil
}
}
func (c *Server) loadConfig(v *viper.Viper) error {
v.SetEnvPrefix("APP")
c.Host = v.GetString("HOST")
c.Port = v.GetInt("PORT")
c.ReadTimeout = v.GetDuration("READ_TIMEOUT")
c.WriteTimeout = v.GetDuration("WRITE_TIMEOUT")
c.IdleTimeout = v.GetDuration("IDLE_TIMEOUT")
c.ShutdownTimeout = v.GetDuration("SHUTDOWN_TIMEOUT")
c.Enabled = v.GetBool("ENABLED")
return c.Validate()
}
func (c *Server) BindAddress() string {
return fmt.Sprintf("%s:%d", c.Host, c.Port)
}
func (c *Server) copy() *Server {
return &Server{
Host: c.Host,
Port: c.Port,
ReadTimeout: c.ReadTimeout,
WriteTimeout: c.WriteTimeout,
IdleTimeout: c.IdleTimeout,
ShutdownTimeout: c.ShutdownTimeout,
Enabled: c.Enabled,
}
}
+11
View File
@@ -0,0 +1,11 @@
package config
import "fmt"
func wrapValidationError(name string, err error) error {
if err == nil {
return nil
}
return fmt.Errorf("%s validation error: %w", name, err)
}
+126
View File
@@ -0,0 +1,126 @@
package dto
import (
"errors"
"net/netip"
"time"
"github.com/google/uuid"
"gitea.privcloud.tech/mtusi2026/internal/pkg/types/role"
)
// ---- Tokens ----
type UserDataInToken struct {
TokenID uuid.UUID
UserID uuid.UUID
Role role.Role
IsAccess bool
PhoneNumber *string
Email *string
ExpiresAt time.Time
IssuedAt time.Time
}
func (u UserDataInToken) Validate() error {
if u.TokenID == uuid.Nil {
return errors.New("invalid token id")
}
if u.UserID == uuid.Nil {
return errors.New("invalid user id")
}
if !u.Role.IsValid() {
return errors.New("invalid role")
}
if u.ExpiresAt.IsZero() {
return errors.New("invalid expiry")
}
if u.IssuedAt.IsZero() {
return errors.New("invalid issued")
}
return nil
}
type Token struct {
Payload string
}
type (
AccessToken Token
RefreshToken Token
)
type Tokens struct {
AccessToken AccessToken
RefreshToken RefreshToken
}
func (t AccessToken) Token() *Token {
return new(Token(t))
}
func (t RefreshToken) Token() *Token {
return new(Token(t))
}
type StoredRefreshToken struct {
ID uuid.UUID
UserID uuid.UUID
TokenHash string
UserAgent string
IPAddress netip.Addr
Role role.Role
ExpiresAt time.Time
RevokedAt *time.Time
CreatedAt time.Time
}
type RevokeRefreshToken struct {
ID uuid.UUID
RevokedAt time.Time
}
type RevokeRefreshTokensByUserID struct {
UserID uuid.UUID
RevokedAt time.Time
}
// ---- Auth ----
type Session struct {
ExpiresAt time.Time
Token string
TokenType string
User User
}
type Login struct {
Username string
Password string
}
type LoginResult struct {
ExpiresAt time.Time
TokenType string
User User
Tokens Tokens
}
// UserCredentials is internal authentication data, never a public user response.
type UserCredentials struct {
User User
PasswordHash string `json:"-"`
}
type Logout struct {
Token string
}
type Register struct {
Email string
Password string
RepeatPassword string
}
+31
View File
@@ -0,0 +1,31 @@
package dto
import (
"time"
"github.com/google/uuid"
)
type Chat struct {
ID uuid.UUID
Title string
MemberIDs []uuid.UUID
CreatedAt time.Time
}
type CreateChat struct {
CreatorID uuid.UUID
Title string
MemberIDs []uuid.UUID
}
type ChatMember struct {
UserID uuid.UUID
ChatID uuid.UUID
}
type ChatFilters struct {
UserID uuid.UUID
Limit *int
AfterID *uuid.UUID
}
+28
View File
@@ -0,0 +1,28 @@
package dto
import (
"time"
"github.com/google/uuid"
)
type Message struct {
ID uuid.UUID
ChatID uuid.UUID
SenderID uuid.UUID
Text string
CreatedAt time.Time
}
type CreateMessage struct {
ChatID uuid.UUID
SenderID uuid.UUID
Text string
}
type MessageFilters struct {
ChatID uuid.UUID
UserID uuid.UUID
Limit *int
AfterID *uuid.UUID
}
+25
View File
@@ -0,0 +1,25 @@
package dto
import (
"time"
"github.com/google/uuid"
)
// Page is a page of records with the ID to use for the next page.
type Page[T any] struct {
Items []T
NextCursorID *uuid.UUID
}
// PagePosition is a resolved database cursor, ordered by creation time and ID.
type PagePosition struct {
CreatedAt time.Time
ID uuid.UUID
}
// PageQuery is prepared by a service; Limit includes the lookahead row.
type PageQuery struct {
Limit int
After *PagePosition
}
+30
View File
@@ -0,0 +1,30 @@
package dto
import (
"time"
"github.com/google/uuid"
)
type User struct {
ID uuid.UUID
Username string
DisplayName string
CreatedAt time.Time
}
type CreateUser struct {
Username string
DisplayName string
Password string
}
// CreateStoredUser contains the prepared database record, never a plaintext password.
type CreateStoredUser struct {
ID uuid.UUID
Username string
DisplayName string
PasswordHash string `json:"-"`
CreatedAt time.Time
UpdatedAt time.Time
}
+137
View File
@@ -0,0 +1,137 @@
// Package contracts provides primitives to interact with the openapi HTTP API.
//
// Code generated by github.com/oapi-codegen/oapi-codegen/v2 version v2.5.1 DO NOT EDIT.
package contracts
import (
"time"
openapi_types "github.com/oapi-codegen/runtime/types"
)
const (
BasicAuthScopes = "basicAuth.Scopes"
BearerAuthScopes = "bearerAuth.Scopes"
)
// Defines values for ErrorErrorCode.
const (
Conflict ErrorErrorCode = "conflict"
InternalError ErrorErrorCode = "internal_error"
InvalidRequest ErrorErrorCode = "invalid_request"
NotFound ErrorErrorCode = "not_found"
PayloadTooLarge ErrorErrorCode = "payload_too_large"
RateLimited ErrorErrorCode = "rate_limited"
Unauthorized ErrorErrorCode = "unauthorized"
Unavailable ErrorErrorCode = "unavailable"
UnsupportedMediaType ErrorErrorCode = "unsupported_media_type"
)
// Defines values for HealthStatus.
const (
Ok HealthStatus = "ok"
)
// Chat defines model for Chat.
type Chat struct {
CreatedAt time.Time `json:"created_at"`
Id openapi_types.UUID `json:"id"`
MemberIds []openapi_types.UUID `json:"member_ids"`
Title string `json:"title"`
}
// ChatPage defines model for ChatPage.
type ChatPage struct {
Items []Chat `json:"items"`
NextCursor *string `json:"next_cursor"`
}
// CreateChat defines model for CreateChat.
type CreateChat struct {
MemberIds []openapi_types.UUID `json:"member_ids"`
Title string `json:"title"`
}
// CreateMessage defines model for CreateMessage.
type CreateMessage struct {
Text string `json:"text"`
}
// CreateUser defines model for CreateUser.
type CreateUser struct {
DisplayName string `json:"display_name"`
Password *string `json:"password,omitempty"`
Username string `json:"username"`
}
// Error defines model for Error.
type Error struct {
Error struct {
Code ErrorErrorCode `json:"code"`
Message string `json:"message"`
RequestId string `json:"request_id"`
} `json:"error"`
}
// ErrorErrorCode defines model for Error.Error.Code.
type ErrorErrorCode string
// Health defines model for Health.
type Health struct {
Status HealthStatus `json:"status"`
}
// HealthStatus defines model for Health.Status.
type HealthStatus string
// Message defines model for Message.
type Message struct {
ChatId openapi_types.UUID `json:"chat_id"`
CreatedAt time.Time `json:"created_at"`
Id openapi_types.UUID `json:"id"`
SenderId openapi_types.UUID `json:"sender_id"`
Text string `json:"text"`
}
// MessagePage defines model for MessagePage.
type MessagePage struct {
Items []Message `json:"items"`
NextCursor *string `json:"next_cursor"`
}
// Session defines model for Session.
type Session struct {
ExpiresAt time.Time `json:"expires_at"`
Token string `json:"token"`
TokenType string `json:"token_type"`
User User `json:"user"`
}
// User defines model for User.
type User struct {
CreatedAt time.Time `json:"created_at"`
DisplayName string `json:"display_name"`
Id openapi_types.UUID `json:"id"`
Username string `json:"username"`
}
// ListChatsParams defines parameters for ListChats.
type ListChatsParams struct {
Limit *int `form:"limit,omitempty" json:"limit,omitempty"`
Cursor *string `form:"cursor,omitempty" json:"cursor,omitempty"`
}
// ListMessagesParams defines parameters for ListMessages.
type ListMessagesParams struct {
Limit *int `form:"limit,omitempty" json:"limit,omitempty"`
Cursor *string `form:"cursor,omitempty" json:"cursor,omitempty"`
}
// CreateChatJSONRequestBody defines body for CreateChat for application/json ContentType.
type CreateChatJSONRequestBody = CreateChat
// CreateMessageJSONRequestBody defines body for CreateMessage for application/json ContentType.
type CreateMessageJSONRequestBody = CreateMessage
// RegisterUserJSONRequestBody defines body for RegisterUser for application/json ContentType.
type RegisterUserJSONRequestBody = CreateUser
+274
View File
@@ -0,0 +1,274 @@
package apperr
import (
"errors"
"net/http"
"github.com/jackc/pgerrcode"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
grpcCodes "google.golang.org/grpc/codes"
)
//go:generate stringer -type=Code -linecomment
type Code uint16
const (
// CodeBadRequest = {AppError: BAD_REQUEST, HTTP:400}
CodeBadRequest Code = iota
// CodePayloadTooLarge = {AppError: REQUEST_ENTITY_TOO_LARGE, HTTP:413}
CodePayloadTooLarge
// CodeValidation = {AppError: VALIDATION, HTTP:400}
CodeValidation
// CodeUnauthorized = {AppError: UNAUTHORIZED, HTTP:401}
CodeUnauthorized
// CodeForbidden = {AppError: FORBIDDEN, HTTP:403}
CodeForbidden
// CodeNotFound = {AppError: NOT_FOUND, HTTP:404}
CodeNotFound
// CodeAlreadyExists = {AppError: ALREADY_EXISTS, HTTP:409}
CodeAlreadyExists
// CodeConflict = {AppError: CONFLICT, HTTP:409}
CodeConflict
// CodeTooManyRequests = {AppError: TOO_MANY_REQUESTS, HTTP:429}
CodeTooManyRequests
// CodeTimeout = {AppError: TIMEOUT, HTTP:504}
CodeTimeout
// CodeInternal = {AppError: INTERNAL, HTTP:500}
CodeInternal
// CodeServiceUnavailable = {AppError: SERVICE_UNAVAILABLE, HTTP:503}
CodeServiceUnavailable
// CodeOK = {AppError: OK, HTTP:200}
CodeOK
// CodeLocked = {AppError: LOCKED, HTTP:423}
CodeLocked
// CodeUnsupportedMediaType = {AppError: UNSUPPORTED_MEDIA_TYPE, HTTP:415}
CodeUnsupportedMediaType
// CodeUnavailable = {AppError: SERVICE_UNAVAILABLE, HTTP: 503}
CodeUnavailable
)
func (c Code) HTTPStatus() int {
if status, ok := httpStatusByCode[c]; ok {
return status
}
return http.StatusInternalServerError
}
func (c Code) GRPCCode() grpcCodes.Code {
if code, ok := grpcCodeByCode[c]; ok {
return code
}
return grpcCodes.Internal
}
func (c Code) PostgresCodes() []string {
codes := postgresCodesByCode[c]
if len(codes) == 0 {
return nil
}
cp := make([]string, len(codes))
copy(cp, codes)
return cp
}
func (c Code) PostgresCode() string {
codes := c.PostgresCodes()
if len(codes) == 0 {
return ""
}
return codes[0]
}
func CodeFromError(err error) Code {
if err == nil {
return CodeInternal
}
var coded interface {
Code() Code
}
if errors.As(err, &coded) {
return coded.Code()
}
if code, ok := codeFromRedisError(err, false, false); ok {
return code
}
return CodeFromPostgresError(err)
}
func HTTPStatusFromError(err error) int {
return CodeFromError(err).HTTPStatus()
}
func GRPCCodeFromError(err error) grpcCodes.Code {
return CodeFromError(err).GRPCCode()
}
func CodeFromHTTPStatus(status int) Code {
if code, ok := codeByHTTPStatus[status]; ok {
return code
}
return CodeInternal
}
func CodeFromGRPC(code grpcCodes.Code) Code {
if appCode, ok := codeByGRPCCode[code]; ok {
return appCode
}
return CodeInternal
}
func CodeFromPostgres(pgCode string) Code {
if code, ok := codeByPostgresCode[pgCode]; ok {
return code
}
return CodeInternal
}
func CodeFromPostgresError(err error) Code {
if err == nil {
return CodeInternal
}
if code, ok := codeByPgxError[err]; ok {
return code
}
if pgErr, ok := errors.AsType[*pgconn.PgError](err); ok {
return CodeFromPostgres(pgErr.Code)
}
return CodeInternal
}
var (
httpStatusByCode = map[Code]int{
CodeBadRequest: http.StatusBadRequest,
CodeUnauthorized: http.StatusUnauthorized,
CodeForbidden: http.StatusForbidden,
CodeNotFound: http.StatusNotFound,
CodeAlreadyExists: http.StatusConflict,
CodeConflict: http.StatusConflict,
CodePayloadTooLarge: http.StatusRequestEntityTooLarge,
CodeTooManyRequests: http.StatusTooManyRequests,
CodeValidation: http.StatusBadRequest,
CodeTimeout: http.StatusGatewayTimeout,
CodeInternal: http.StatusInternalServerError,
CodeServiceUnavailable: http.StatusServiceUnavailable,
CodeUnsupportedMediaType: http.StatusUnsupportedMediaType,
CodeUnavailable: http.StatusServiceUnavailable,
CodeOK: http.StatusOK,
CodeLocked: http.StatusLocked,
}
codeByHTTPStatus = map[int]Code{
http.StatusBadRequest: CodeBadRequest,
http.StatusUnauthorized: CodeUnauthorized,
http.StatusForbidden: CodeForbidden,
http.StatusNotFound: CodeNotFound,
http.StatusConflict: CodeConflict,
http.StatusRequestEntityTooLarge: CodePayloadTooLarge,
http.StatusTooManyRequests: CodeTooManyRequests,
http.StatusUnprocessableEntity: CodeValidation,
http.StatusGatewayTimeout: CodeTimeout,
http.StatusInternalServerError: CodeInternal,
http.StatusServiceUnavailable: CodeServiceUnavailable,
http.StatusOK: CodeOK,
http.StatusLocked: CodeLocked,
http.StatusUnsupportedMediaType: CodeUnavailable,
}
grpcCodeByCode = map[Code]grpcCodes.Code{
CodeBadRequest: grpcCodes.InvalidArgument,
CodePayloadTooLarge: grpcCodes.ResourceExhausted,
CodeValidation: grpcCodes.InvalidArgument,
CodeUnauthorized: grpcCodes.Unauthenticated,
CodeForbidden: grpcCodes.PermissionDenied,
CodeNotFound: grpcCodes.NotFound,
CodeAlreadyExists: grpcCodes.AlreadyExists,
CodeConflict: grpcCodes.Aborted,
CodeTooManyRequests: grpcCodes.ResourceExhausted,
CodeTimeout: grpcCodes.DeadlineExceeded,
CodeInternal: grpcCodes.Internal,
CodeServiceUnavailable: grpcCodes.Unavailable,
CodeOK: grpcCodes.OK,
CodeLocked: grpcCodes.FailedPrecondition,
}
codeByGRPCCode = map[grpcCodes.Code]Code{
grpcCodes.InvalidArgument: CodeBadRequest,
grpcCodes.ResourceExhausted: CodeTooManyRequests,
grpcCodes.Unauthenticated: CodeUnauthorized,
grpcCodes.PermissionDenied: CodeForbidden,
grpcCodes.NotFound: CodeNotFound,
grpcCodes.AlreadyExists: CodeAlreadyExists,
grpcCodes.Aborted: CodeConflict,
grpcCodes.FailedPrecondition: CodeLocked,
grpcCodes.DeadlineExceeded: CodeTimeout,
grpcCodes.Internal: CodeInternal,
grpcCodes.Unimplemented: CodeInternal,
grpcCodes.Unavailable: CodeServiceUnavailable,
grpcCodes.OK: CodeOK,
}
postgresCodesByCode = map[Code][]string{
CodeBadRequest: {
pgerrcode.InvalidTextRepresentation,
pgerrcode.InvalidParameterValue,
},
CodeValidation: {
pgerrcode.NotNullViolation,
pgerrcode.CheckViolation,
pgerrcode.StringDataRightTruncationDataException,
pgerrcode.NumericValueOutOfRange,
},
CodeNotFound: {
pgerrcode.ForeignKeyViolation,
},
CodeAlreadyExists: {
pgerrcode.UniqueViolation,
},
CodeConflict: {
pgerrcode.ExclusionViolation,
pgerrcode.SerializationFailure,
pgerrcode.DeadlockDetected,
},
CodeLocked: {
pgerrcode.LockNotAvailable,
pgerrcode.ObjectInUse,
},
CodeTooManyRequests: {
pgerrcode.TooManyConnections,
},
CodeTimeout: {
pgerrcode.QueryCanceled,
},
CodeInternal: {
pgerrcode.ConnectionException,
pgerrcode.ConnectionFailure,
pgerrcode.SQLClientUnableToEstablishSQLConnection,
pgerrcode.SQLServerRejectedEstablishmentOfSQLConnection,
pgerrcode.TransactionResolutionUnknown,
},
CodeServiceUnavailable: {
pgerrcode.CannotConnectNow,
},
}
codeByPostgresCode = buildCodeByPostgresCode(postgresCodesByCode)
codeByPgxError = map[error]Code{
pgx.ErrNoRows: CodeNotFound,
pgx.ErrTxClosed: CodeInternal,
pgx.ErrTxCommitRollback: CodeConflict,
pgx.ErrTooManyRows: CodeInternal,
}
)
func buildCodeByPostgresCode(src map[Code][]string) map[string]Code {
dst := make(map[string]Code, len(src))
for code, pgCodes := range src {
for _, pgCode := range pgCodes {
dst[pgCode] = code
}
}
return dst
}
@@ -0,0 +1,37 @@
// Code generated by "stringer -type=Code -linecomment"; DO NOT EDIT.
package apperr
import "strconv"
func _() {
// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
var x [1]struct{}
_ = x[CodeBadRequest-0]
_ = x[CodePayloadTooLarge-1]
_ = x[CodeValidation-2]
_ = x[CodeUnauthorized-3]
_ = x[CodeForbidden-4]
_ = x[CodeNotFound-5]
_ = x[CodeAlreadyExists-6]
_ = x[CodeConflict-7]
_ = x[CodeTooManyRequests-8]
_ = x[CodeTimeout-9]
_ = x[CodeInternal-10]
_ = x[CodeServiceUnavailable-11]
_ = x[CodeOK-12]
_ = x[CodeLocked-13]
}
const _Code_name = "CodeBadRequestCodePayloadTooLargeCodeValidationCodeUnauthorizedCodeForbiddenCodeNotFoundCodeAlreadyExistsCodeConflictCodeTooManyRequestsCodeTimeoutCodeInternalCodeServiceUnavailableCodeOKCodeLocked"
var _Code_index = [...]uint8{0, 14, 33, 47, 63, 76, 88, 105, 117, 136, 147, 159, 181, 187, 197}
func (i Code) String() string {
idx := int(i) - 0
if i < 0 || idx >= len(_Code_index)-1 {
return "Code(" + strconv.FormatInt(int64(i), 10) + ")"
}
return _Code_name[_Code_index[idx]:_Code_index[idx+1]]
}
+123
View File
@@ -0,0 +1,123 @@
package apperr
import (
"errors"
"fmt"
grpcCodes "google.golang.org/grpc/codes"
)
type AppError struct {
err error
msg string
code Code
meta metadata
}
func New(code Code, msg string) error {
return &AppError{
msg: msg,
code: code,
meta: metadata{},
}
}
func Wrap(err error, code Code, msg string) error {
m := AppError{
err: err,
msg: msg,
code: code,
meta: metadata{},
}
return &m
}
func WrapAppError(err error, msg string) error {
m := AppError{
err: err,
msg: msg,
code: CodeInternal,
meta: metadata{},
}
if mistake := As(err); mistake != nil {
m.err = mistake
m.code = mistake.code
m.meta = mistake.meta
}
return &m
}
func As(err error) *AppError {
if mistakeErr, ok := errors.AsType[*AppError](err); ok {
return mistakeErr
}
return nil
}
func CodeIs(err error, code Code) bool {
if appErr := As(err); appErr != nil && appErr.Code() == code {
return true
}
return false
}
func (e *AppError) Error() string {
if e == nil {
return ""
}
if e.err == nil {
if e.msg != "" {
return e.msg
}
return e.code.String()
}
if e.msg == "" {
return e.err.Error()
}
return fmt.Sprintf("%s: %s", e.msg, e.err.Error())
}
func (e *AppError) Unwrap() error {
if e == nil {
return nil
}
return e.err
}
func (e *AppError) Code() Code {
if e == nil {
return CodeInternal
}
return e.code
}
func (e *AppError) Message() string {
if e == nil {
return ""
}
return e.msg
}
func (e *AppError) Cause() error {
if e == nil {
return nil
}
return e.err
}
func (e *AppError) Metadata() Metadata {
return e.meta
}
func (e *AppError) HTTPStatus() int {
return e.Code().HTTPStatus()
}
func (e *AppError) GRPCCode() grpcCodes.Code {
return e.Code().GRPCCode()
}
+42
View File
@@ -0,0 +1,42 @@
package apperr
import (
"fmt"
"maps"
"strings"
)
var _ Metadata = (*metadata)(nil)
type Metadata interface {
Get(key metakey) string
Clone() map[metakey]string
CloneToAnyMap() map[string]any
String() string
}
type metadata map[metakey]string
func (m metadata) Get(key metakey) string {
return m[key]
}
func (m metadata) Clone() map[metakey]string {
return maps.Clone(m)
}
func (m metadata) CloneToAnyMap() map[string]any {
newM := make(map[string]any, len(m))
for k, v := range m {
newM[k.String()] = v
}
return newM
}
func (m metadata) String() string {
var b strings.Builder
for k, v := range m {
b.WriteString(fmt.Sprintf("%s: %s, ", k, v))
}
return b.String()
}
+19
View File
@@ -0,0 +1,19 @@
package apperr
type metakey uint16
const (
PgErrorCode metakey = iota
RedisErrorCode
)
func (m metakey) String() string {
switch m {
case PgErrorCode:
return "pg_err_code"
case RedisErrorCode:
return "redis_err_code"
default:
return "unknown"
}
}
+81
View File
@@ -0,0 +1,81 @@
package apperr
import (
"context"
"errors"
"fmt"
"io"
"net"
"strings"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
)
func WrapPostgres(err error, msg string) error {
m := AppError{
err: err,
msg: msg,
code: CodeInternal,
meta: metadata{},
}
m.handlePostgres()
return &m
}
func (e *AppError) handlePostgres() {
if e.err == nil {
e.code = CodeOK
return
}
var networkError net.Error
var connectError *pgconn.ConnectError
if errors.Is(e.err, context.DeadlineExceeded) || errors.Is(e.err, io.EOF) ||
errors.Is(e.err, io.ErrUnexpectedEOF) || errors.As(e.err, &networkError) || errors.As(e.err, &connectError) {
e.code = CodeServiceUnavailable
e.msg = "database unavailable"
return
}
if pgErr, ok := errors.AsType[*pgconn.PgError](e.err); ok {
if strings.HasPrefix(pgErr.Code, "08") || pgErr.Code == "57014" ||
pgErr.Code == "57P01" || pgErr.Code == "57P02" || pgErr.Code == "57P03" || pgErr.Code == "53300" {
e.code = CodeServiceUnavailable
e.msg = "database unavailable"
return
}
e.meta[PgErrorCode] = pgErr.Code
e.code = CodeFromPostgres(pgErr.Code)
return
}
switch {
case errors.Is(e.err, pgx.ErrNoRows):
e.msg = fmt.Sprintf("not found: %s", e.msg)
e.code = CodeNotFound
return
case errors.Is(e.err, pgx.ErrTooManyRows):
e.msg = fmt.Sprintf("got too many rows: %s", e.msg)
e.code = CodeInternal
return
case errors.Is(e.err, pgx.ErrTxClosed):
e.msg = fmt.Sprintf("transaction is closed: %s", e.msg)
e.code = CodeInternal
return
case errors.Is(e.err, pgx.ErrTxCommitRollback):
e.msg = fmt.Sprintf("transaction commit resulted in rollback: %s", e.msg)
e.code = CodeInternal
return
}
}
func (e *AppError) PgCode() string {
if e == nil {
return ""
}
if e.meta == nil {
return ""
}
return e.meta.Get(PgErrorCode)
}
+170
View File
@@ -0,0 +1,170 @@
package apperr
import (
"context"
"errors"
"fmt"
"net"
"strings"
"github.com/redis/go-redis/v9"
)
func WrapRedis(err error, msg string) error {
m := AppError{
err: err,
msg: msg,
meta: metadata{},
}
m.handleRedis()
return &m
}
func CodeFromRedisError(err error) Code {
code, ok := codeFromRedisError(err, true, true)
if !ok {
return CodeInternal
}
return code
}
func (e *AppError) handleRedis() {
if e.err == nil {
e.code = CodeOK
return
}
if code := redisErrorCode(e.err); code != "" {
e.meta[RedisErrorCode] = code
}
if errors.Is(e.err, redis.Nil) {
e.msg = fmt.Sprintf("not found: %s", e.msg)
}
e.code = CodeFromRedisError(e.err)
}
func (e *AppError) RedisCode() string {
if e == nil {
return ""
}
if e.meta == nil {
return ""
}
return e.meta.Get(RedisErrorCode)
}
func codeFromRedisError(err error, includeTransport bool, includeProtocolString bool) (Code, bool) {
if err == nil {
return CodeInternal, false
}
switch {
case errors.Is(err, redis.Nil):
return CodeNotFound, true
case errors.Is(err, redis.TxFailedErr):
return CodeConflict, true
case errors.Is(err, redis.ErrCrossSlot):
return CodeBadRequest, true
case errors.Is(err, redis.ErrPoolTimeout):
return CodeTimeout, true
case errors.Is(err, redis.ErrPoolExhausted):
return CodeTooManyRequests, true
case errors.Is(err, redis.ErrClosed):
return CodeServiceUnavailable, true
}
if includeTransport {
if errors.Is(err, context.Canceled) ||
errors.Is(err, context.DeadlineExceeded) {
return CodeTimeout, true
}
if netErr, ok := errors.AsType[net.Error](err); ok {
if netErr.Timeout() {
return CodeTimeout, true
}
return CodeServiceUnavailable, true
}
}
hasRedisError := isRedisError(err)
if !hasRedisError && !includeProtocolString {
return CodeInternal, false
}
switch {
case redis.IsExecAbortError(err):
return CodeConflict, true
case redis.IsMaxClientsError(err):
return CodeTooManyRequests, true
case redis.IsLoadingError(err),
redis.IsReadOnlyError(err),
redis.IsClusterDownError(err),
redis.IsTryAgainError(err),
redis.IsMasterDownError(err),
redis.IsNoReplicasError(err),
redis.IsOOMError(err):
return CodeServiceUnavailable, true
case redis.IsAuthError(err),
redis.IsPermissionError(err):
return CodeInternal, true
}
if _, ok := redis.IsMovedError(err); ok {
return CodeServiceUnavailable, true
}
if _, ok := redis.IsAskError(err); ok {
return CodeServiceUnavailable, true
}
if hasRedisError {
return CodeInternal, true
}
return CodeInternal, false
}
func isRedisError(err error) bool {
if err == nil {
return false
}
var redisErr redis.Error
return errors.As(err, &redisErr)
}
func redisErrorCode(err error) string {
switch {
case err == nil:
return ""
case errors.Is(err, redis.Nil):
return "nil"
case errors.Is(err, redis.TxFailedErr):
return "tx_failed"
case errors.Is(err, redis.ErrCrossSlot):
return "CROSSSLOT"
case errors.Is(err, redis.ErrPoolTimeout):
return "pool_timeout"
case errors.Is(err, redis.ErrPoolExhausted):
return "pool_exhausted"
case errors.Is(err, redis.ErrClosed):
return "closed"
}
var redisErr redis.Error
if !errors.As(err, &redisErr) {
return ""
}
msg := strings.TrimSpace(redisErr.Error())
msg = strings.TrimPrefix(msg, "ERR ")
parts := strings.Fields(msg)
if len(parts) == 0 {
return ""
}
return parts[0]
}
@@ -0,0 +1,145 @@
package jwtprovider
import (
"fmt"
"log/slog"
"time"
"github.com/golang-jwt/jwt/v5"
"github.com/google/uuid"
"gitea.privcloud.tech/mtusi2026/internal/dto"
"gitea.privcloud.tech/mtusi2026/internal/pkg/types/role"
)
var _ Claims = (*jwtClaims)(nil)
type Claims interface {
GetTopTokenID() (uuid.UUID, bool)
GetTopUserID() (uuid.UUID, bool)
GetTopRole() (role.Role, bool)
GetTopIsAccess() (bool, bool)
GetTopExpiresAt() (time.Time, bool)
GetTopIssuedAt() (time.Time, bool)
}
type claimsParseFunc func(token *dto.Token) (*jwtClaims, error)
type jwtClaims struct {
jwt.RegisteredClaims
Nonce string `json:"nonce,omitempty"`
IsAccess bool `json:"is_access"`
Role role.Role `json:"role"`
}
func (claims *jwtClaims) GetTopTokenID() (uuid.UUID, bool) {
parsed, err := uuid.Parse(claims.ID)
if err != nil {
return uuid.Nil, false
}
return parsed, true
}
func (claims *jwtClaims) GetTopUserID() (uuid.UUID, bool) {
parsed, err := uuid.Parse(claims.Subject)
if err != nil {
return uuid.Nil, false
}
return parsed, true
}
func (claims *jwtClaims) GetTopRole() (role.Role, bool) {
return claims.Role, true
}
func (claims *jwtClaims) GetTopIsAccess() (bool, bool) {
return claims.IsAccess, true
}
func (claims *jwtClaims) GetTopExpiresAt() (time.Time, bool) {
if claims.ExpiresAt == nil {
return time.Time{}, false
}
return claims.ExpiresAt.Time, true
}
func (claims *jwtClaims) GetTopIssuedAt() (time.Time, bool) {
if claims.IssuedAt == nil {
return time.Time{}, false
}
return claims.IssuedAt.Time, true
}
func (claims *jwtClaims) userData() (*dto.UserDataInToken, error) {
var u dto.UserDataInToken
tokenID, err := uuid.Parse(claims.ID)
if err != nil {
return nil, fmt.Errorf("failed to parse token id: %w", err)
}
u.TokenID = tokenID
userID, err := uuid.Parse(claims.Subject)
if err != nil {
return nil, fmt.Errorf("failed to parse user id from token %q: %w", claims.Subject, err)
}
u.UserID = userID
u.Role = claims.Role
u.IsAccess = claims.IsAccess
if claims.ExpiresAt != nil {
u.ExpiresAt = claims.ExpiresAt.Time
}
if claims.IssuedAt != nil {
u.IssuedAt = claims.IssuedAt.Time
}
return &u, nil
}
func (p *provider) parseClaimsFromProtectedJWT(token *dto.Token) (*jwtClaims, error) {
if token == nil {
return nil, ErrTokenIsMissing
}
claims := &jwtClaims{}
parsed, err := jwt.ParseWithClaims(
token.Payload,
claims,
p.readKeyFunc,
jwt.WithValidMethods([]string{jwt.SigningMethodRS256.Alg()}),
jwt.WithExpirationRequired(),
jwt.WithIssuedAt(),
)
if err != nil {
slog.Error("failed to parse token with claims", "error", err)
return nil, ErrInvalidToken
}
if !parsed.Valid {
slog.Error("failed to parse token: provided invalid token", "valid", parsed.Valid)
return nil, ErrInvalidToken
}
return claims, nil
}
func (p *provider) parseClaimsFromExposedJWT(token *dto.Token) (*jwtClaims, error) {
if token == nil {
return nil, ErrTokenIsMissing
}
claims := &jwtClaims{}
_, _, err := new(jwt.Parser).ParseUnverified(token.Payload, claims)
if err != nil {
slog.Error("failed to parse token: provided invalid token")
return nil, ErrInvalidToken
}
return claims, nil
}
@@ -0,0 +1,84 @@
package jwtprovider
import (
"net/http"
)
const (
accessTokenCookieKey = "auth-access-token"
refreshTokenCookieKey = "auth-refresh-token"
expiresAtCookieKey = "auth-exp"
)
type CookieBuilderFabric struct {
fabric func() http.Cookie
}
func newCookieBuilder(
domain string,
path string,
secure bool,
sameSite http.SameSite,
) *CookieBuilderFabric {
return &CookieBuilderFabric{
fabric: newCookieFabric(domain, path, secure, sameSite),
}
}
func (b *CookieBuilderFabric) Builder() *CookieBuilder {
return &CookieBuilder{
cookie: b.fabric(),
}
}
func newCookieFabric(
_ string,
path string,
secure bool,
sameSite http.SameSite) func() http.Cookie {
return func() http.Cookie {
return http.Cookie{
Path: path,
Secure: secure,
SameSite: sameSite,
}
}
}
type CookieBuilder struct {
cookie http.Cookie
}
func (b *CookieBuilder) AccessName() *CookieBuilder {
b.cookie.Name = accessTokenCookieKey
return b
}
func (b *CookieBuilder) ExpiresName() *CookieBuilder {
b.cookie.Name = expiresAtCookieKey
return b
}
func (b *CookieBuilder) RefreshName() *CookieBuilder {
b.cookie.Name = refreshTokenCookieKey
return b
}
func (b *CookieBuilder) Value(value string) *CookieBuilder {
b.cookie.Value = value
return b
}
func (b *CookieBuilder) HTTPOnly() *CookieBuilder {
b.cookie.HttpOnly = true
return b
}
func (b *CookieBuilder) MaxAge(maxAge int) *CookieBuilder {
b.cookie.MaxAge = maxAge
return b
}
func (b *CookieBuilder) Build() *http.Cookie {
return new(b.cookie)
}
@@ -0,0 +1,18 @@
package jwtprovider
import (
"errors"
)
var (
ErrDecode = errors.New("failed to decode argument")
ErrNotFound = errors.New("not found")
ErrUnexpectedAlgorithm = errors.New("unexpected signing algorithm")
ErrTokenIsMissing = errors.New("token is missing")
ErrInvalidToken = errors.New("provided invalid token")
ErrInvalidUserDataInToken = errors.New("invalid user data in token")
ErrInvalidTokenClaims = errors.New("provided invalid token claims")
ErrInvalidBirthDateFormat = errors.New("provided invalid birth date format")
ErrTokenExpired = errors.New("token is expired")
ErrFailedToSign = errors.New("failed to sign jwt")
)
@@ -0,0 +1,26 @@
package jwtprovider
import (
"net/http"
"github.com/google/uuid"
"gitea.privcloud.tech/mtusi2026/internal/dto"
"gitea.privcloud.tech/mtusi2026/internal/pkg/types/role"
)
type Provider interface {
Parse(token *dto.Token) (*dto.UserDataInToken, error)
CreateRefreshAndAccessTokensForUser(userID uuid.UUID, role role.Role) (*dto.Tokens, error)
ParseVerified(token *dto.Token) (*dto.UserDataInToken, error)
ParseUnverified(token *dto.Token) (*dto.UserDataInToken, error)
ValidateUserDataInToken(u *dto.UserDataInToken) error
}
type Cookie interface {
Enabled() bool
Set(w http.ResponseWriter, tokens *dto.Tokens)
Clear(w http.ResponseWriter)
AccessToken(r *http.Request) *dto.AccessToken
RefreshToken(r *http.Request) *dto.RefreshToken
}
@@ -0,0 +1,199 @@
package jwtprovider
import (
"fmt"
"net/http"
"strconv"
"time"
"gitea.privcloud.tech/mtusi2026/internal/config"
"gitea.privcloud.tech/mtusi2026/internal/dto"
)
type manager struct {
enabled bool
cookieFabric *CookieBuilderFabric
prv Provider
}
func NewCookieManager(cfg *config.Config, provider Provider) Cookie {
m := &manager{
//enabled: cfg.Cookies.Enabled,
//cookieFabric: newCookieBuilder(
// cfg.Cookies.Domain,
// cfg.Cookies.Path,
// cfg.Cookies.Secure,
// cfg.Cookies.SameSite,
//),
prv: provider,
}
if !m.enabled {
return m
}
if err := m.cookieFabric.
Builder().
AccessName().
Value("test").
HTTPOnly().
MaxAge(0).
Build().
Valid(); err != nil {
panic(fmt.Errorf("cookie validation failed: %w", err))
}
return m
}
func (m *manager) Enabled() bool {
return m.enabled
}
func (m *manager) Set(w http.ResponseWriter, tokens *dto.Tokens) {
if !m.enabled || tokens == nil {
return
}
if tokens.AccessToken.Payload != "" {
m.setAccess(tokens.AccessToken, w)
}
if tokens.RefreshToken.Payload != "" {
m.setRefresh(tokens.RefreshToken, w)
}
}
func (m *manager) Clear(w http.ResponseWriter) {
if !m.enabled {
return
}
for _, name := range []string{accessTokenCookieKey, refreshTokenCookieKey, expiresAtCookieKey} {
b := m.cookieFabric.
Builder().
MaxAge(-1)
switch name {
case expiresAtCookieKey:
b.ExpiresName()
case refreshTokenCookieKey:
b.RefreshName().
HTTPOnly()
case accessTokenCookieKey:
b.AccessName().
HTTPOnly()
}
http.SetCookie(w, b.Build())
}
}
func (m *manager) AccessToken(r *http.Request) *dto.AccessToken {
if !m.enabled {
return nil
}
c, err := r.Cookie(accessTokenCookieKey)
if err != nil {
return nil
}
return &dto.AccessToken{
Payload: c.Value,
}
}
func (m *manager) RefreshToken(r *http.Request) *dto.RefreshToken {
if !m.enabled {
return nil
}
c, err := r.Cookie(refreshTokenCookieKey)
if err != nil {
return nil
}
return &dto.RefreshToken{
Payload: c.Value,
}
}
func (m *manager) setAccess(token dto.AccessToken, w http.ResponseWriter) {
accessTTL := m.tokenTTL(token.Token())
if accessTTL < 0 {
http.SetCookie(w, m.cookieFabric.
Builder().
AccessName().
HTTPOnly().
MaxAge(-1).
Build(),
)
http.SetCookie(w, m.cookieFabric.
Builder().
ExpiresName().
MaxAge(-1).
Build(),
)
} else if tokenExpiresAt := m.tokenExpiry(token.Token()); !tokenExpiresAt.IsZero() {
http.SetCookie(w, m.cookieFabric.
Builder().
AccessName().
Value(token.Payload).
HTTPOnly().
MaxAge(accessTTL).
Build(),
)
http.SetCookie(w, m.cookieFabric.
Builder().
ExpiresName().
Value(strconv.FormatInt(tokenExpiresAt.Unix(), 10)).
MaxAge(accessTTL).
Build(),
)
}
}
func (m *manager) setRefresh(token dto.RefreshToken, w http.ResponseWriter) {
refreshTTL := m.tokenTTL(token.Token())
if refreshTTL < 0 {
http.SetCookie(w, m.cookieFabric.
Builder().
RefreshName().
HTTPOnly().
MaxAge(-1).
Build(),
)
} else {
http.SetCookie(w, m.cookieFabric.
Builder().
RefreshName().
Value(token.Payload).
HTTPOnly().
MaxAge(refreshTTL).
Build(),
)
}
}
func (m *manager) tokenTTL(token *dto.Token) int {
expiresAt := m.tokenExpiry(token)
if expiresAt.IsZero() {
return -1
}
ttl := int(time.Until(expiresAt).Seconds())
if ttl <= 0 {
return -1
}
return ttl
}
func (m *manager) tokenExpiry(token *dto.Token) time.Time {
data, err := m.prv.ParseUnverified(token)
if err != nil {
return time.Time{}
}
return data.ExpiresAt
}
@@ -0,0 +1,187 @@
package jwtprovider
import (
"crypto/rand"
"crypto/rsa"
"encoding/base64"
"fmt"
"log/slog"
"time"
"github.com/golang-jwt/jwt/v5"
"github.com/google/uuid"
"gitea.privcloud.tech/mtusi2026/internal/config"
"gitea.privcloud.tech/mtusi2026/internal/dto"
"gitea.privcloud.tech/mtusi2026/internal/pkg/types/environment"
"gitea.privcloud.tech/mtusi2026/internal/pkg/types/role"
)
var (
_ Provider = (*provider)(nil)
)
type provider struct {
accessLifetime time.Duration
refreshLifetime time.Duration
publicKey *rsa.PublicKey
privateKey *rsa.PrivateKey
parseFunc claimsParseFunc
}
func New(cfg *config.Config) Provider {
p := provider{
accessLifetime: cfg.JWT.AccessTokenLifetime,
refreshLifetime: cfg.JWT.RefreshTokenLifetime,
}
p.parseFunc = p.parseClaimsFromProtectedJWT
if cfg.Application.Environment == environment.ApplicationEnvironmentDev {
p.parseFunc = p.parseClaimsFromExposedJWT
}
var err error
if p.publicKey, err = readPublicKeyFromFile(cfg.JWT.PublicKeyPath); err != nil {
slog.Error("failed to read public key", "error", err)
panic(fmt.Errorf("failed to read public key: %w", err))
}
if p.privateKey, err = readPrivateKeyFromFile(cfg.JWT.PrivateKeyPath); err != nil {
slog.Error("failed to read private key", "error", err)
panic(fmt.Errorf("failed to read private key: %w", err))
}
return &p
}
func (p *provider) Parse(token *dto.Token) (*dto.UserDataInToken, error) {
claims, err := p.parseFunc(token)
if err != nil {
return nil, err
}
return claims.userData()
}
func (p *provider) ParseUnverified(t *dto.Token) (*dto.UserDataInToken, error) {
if t == nil {
return nil, ErrTokenIsMissing
}
claims, err := p.parseClaimsFromExposedJWT(t)
if err != nil {
return nil, err
}
return claims.userData()
}
func (p *provider) ParseVerified(t *dto.Token) (*dto.UserDataInToken, error) {
if t == nil {
return nil, ErrTokenIsMissing
}
claims, err := p.parseClaimsFromProtectedJWT(t)
if err != nil {
return nil, fmt.Errorf("failed to parse token: %w", err)
}
return claims.userData()
}
func (p *provider) CreateAccessTokenForUser(userID uuid.UUID, role role.Role) (*dto.AccessToken, error) {
t, err := p.createTokenForUser(userID, true, role)
if err != nil {
return nil, err
}
return &dto.AccessToken{
Payload: t.Payload,
}, nil
}
func (p *provider) CreateRefreshTokenForUser(userID uuid.UUID, role role.Role) (*dto.RefreshToken, error) {
t, err := p.createTokenForUser(userID, false, role)
if err != nil {
return nil, err
}
return &dto.RefreshToken{
Payload: t.Payload,
}, nil
}
func (p *provider) CreateRefreshAndAccessTokensForUser(userID uuid.UUID, role role.Role) (*dto.Tokens, error) {
access, err := p.CreateAccessTokenForUser(userID, role)
if err != nil {
return nil, err
}
refresh, err := p.CreateRefreshTokenForUser(userID, role)
if err != nil {
return nil, err
}
return &dto.Tokens{
AccessToken: *access,
RefreshToken: *refresh,
}, nil
}
func (p *provider) createTokenForUser(userID uuid.UUID, isAccess bool, role role.Role) (*dto.Token, error) {
now := time.Now()
var tokenExpiresAt time.Time
if isAccess {
tokenExpiresAt = now.Add(p.accessLifetime)
} else {
tokenExpiresAt = now.Add(p.refreshLifetime)
}
var nonce [32]byte
if _, err := rand.Read(nonce[:]); err != nil {
return nil, fmt.Errorf("generate token nonce: %w", err)
}
claims := &jwtClaims{
Nonce: base64.RawURLEncoding.EncodeToString(nonce[:]),
RegisteredClaims: jwt.RegisteredClaims{
Subject: userID.String(),
ExpiresAt: jwt.NewNumericDate(tokenExpiresAt),
NotBefore: jwt.NewNumericDate(now),
IssuedAt: jwt.NewNumericDate(now),
ID: uuid.NewString(),
},
IsAccess: isAccess,
Role: role,
}
t := jwt.NewWithClaims(jwt.SigningMethodRS256, claims)
payload, err := t.SignedString(p.privateKey)
if err != nil {
slog.Error("failed to sign jwt", "error", err)
return nil, ErrFailedToSign
}
return &dto.Token{Payload: payload}, nil
}
// TODO refactor maybe delete
func (p *provider) ValidateUserDataInToken(u *dto.UserDataInToken) error {
if u == nil {
return ErrInvalidUserDataInToken
}
switch {
case u.TokenID == uuid.Nil:
return fmt.Errorf("%w: unexpected nil token id", ErrInvalidUserDataInToken)
case u.UserID == uuid.Nil:
return fmt.Errorf("%w: unexpected nil user id", ErrInvalidUserDataInToken)
case u.IssuedAt.IsZero():
return fmt.Errorf("%w: unexpected zero issued at", ErrInvalidUserDataInToken)
case u.Email != nil && *u.Email == "":
return fmt.Errorf("%w: unexpected empty email", ErrInvalidUserDataInToken)
case u.PhoneNumber != nil && *u.PhoneNumber == "":
return fmt.Errorf("%w: unexpected empty phone number", ErrInvalidUserDataInToken)
case u.ExpiresAt.IsZero():
return fmt.Errorf("%w: unexpected zero expires at", ErrInvalidUserDataInToken)
}
return nil
}
func (p *provider) readKeyFunc(token *jwt.Token) (interface{}, error) {
if token.Method != jwt.SigningMethodRS256 {
return nil, fmt.Errorf("unexpected signing method: %v", token.Header["alg"])
}
return p.publicKey, nil
}
@@ -0,0 +1,35 @@
package jwtprovider
import (
"crypto/rsa"
"fmt"
"os"
"github.com/golang-jwt/jwt/v5"
)
func readPrivateKeyFromFile(path string) (*rsa.PrivateKey, error) {
key, err := os.ReadFile(path)
if err != nil {
return nil, fmt.Errorf("failed to read public key: %w", err)
}
privateKey, err := jwt.ParseRSAPrivateKeyFromPEM(key)
if err != nil {
return nil, fmt.Errorf("failed to parse private key: %w", err)
}
return privateKey, nil
}
func readPublicKeyFromFile(path string) (*rsa.PublicKey, error) {
key, err := os.ReadFile(path)
if err != nil {
return nil, fmt.Errorf("failed to read public key: %w", err)
}
privateKey, err := jwt.ParseRSAPublicKeyFromPEM(key)
if err != nil {
return nil, fmt.Errorf("failed to parse private key: %w", err)
}
return privateKey, nil
}
+43
View File
@@ -0,0 +1,43 @@
package cache
import (
"context"
"time"
"github.com/redis/go-redis/v9"
"gitea.privcloud.tech/mtusi2026/internal/config"
)
const defaultRedisPort = 6379
// OperationTimeout bounds each optional cache operation independently of the request.
const OperationTimeout = 300 * time.Millisecond
type Client struct {
*redis.Client
}
func New(cfg *config.Config) *Client {
if cfg.Redis.Port == 0 {
cfg.Redis.Port = defaultRedisPort
}
return &Client{
Client: redis.NewClient(cfg.Redis.BuildRedisOptions()),
}
}
func (c *Client) Ping(ctx context.Context) error {
ctx, cancel := context.WithTimeout(ctx, OperationTimeout)
defer cancel()
return c.Client.Ping(ctx).Err()
}
func (c *Client) Start(ctx context.Context) error {
return c.Ping(ctx)
}
func (c *Client) Stop(_ context.Context) error {
return c.Client.Close()
}
@@ -0,0 +1,71 @@
package encrypting
import (
"context"
"crypto/rand"
"crypto/subtle"
"encoding/base64"
"fmt"
"strings"
"golang.org/x/crypto/argon2"
)
const (
argon2idMemory = 64 * 1024 // KiB
argon2idTime = 3
argon2idThreads = 4
argon2idSaltLen = 16
argon2idKeyLen = 32
// Only this bounded profile is accepted; stored parameters cannot request arbitrary resources.
argon2idPrefix = "$argon2id$v=19$m=65536,t=3,p=4$"
)
func (e *encryptor) EncryptSecretUsingArgon2id(ctx context.Context, secret string) (string, error) {
if err := ctx.Err(); err != nil {
return "", err
}
var salt [argon2idSaltLen]byte
if _, err := rand.Read(salt[:]); err != nil {
return "", fmt.Errorf("%w: %w", ErrFailedToEncryptPassword, err)
}
key := argon2.IDKey([]byte(secret), salt[:], argon2idTime, argon2idMemory, argon2idThreads, argon2idKeyLen)
if err := ctx.Err(); err != nil {
return "", err
}
return argon2idPrefix + base64.RawStdEncoding.EncodeToString(salt[:]) + "$" + base64.RawStdEncoding.EncodeToString(key), nil
}
func (e *encryptor) CompareHashAndSecretUsingArgon2id(ctx context.Context, hash, secret string) error {
if err := ctx.Err(); err != nil {
return err
}
encoding := base64.RawStdEncoding.Strict()
if len(hash) != len(argon2idPrefix)+encoding.EncodedLen(argon2idSaltLen)+1+encoding.EncodedLen(argon2idKeyLen) {
return ErrFailedToComparePasswords
}
payload, ok := strings.CutPrefix(hash, argon2idPrefix)
if !ok {
return ErrFailedToComparePasswords
}
saltText, keyText, ok := strings.Cut(payload, "$")
if !ok {
return ErrFailedToComparePasswords
}
salt, err := encoding.DecodeString(saltText)
if err != nil || len(salt) != argon2idSaltLen {
return ErrFailedToComparePasswords
}
storedKey, err := encoding.DecodeString(keyText)
if err != nil || len(storedKey) != argon2idKeyLen {
return ErrFailedToComparePasswords
}
key := argon2.IDKey([]byte(secret), salt, argon2idTime, argon2idMemory, argon2idThreads, argon2idKeyLen)
if err = ctx.Err(); err != nil {
return err
}
if subtle.ConstantTimeCompare(storedKey, key) != 1 {
return ErrFailedToComparePasswords
}
return nil
}
@@ -0,0 +1,57 @@
package encrypting
import (
"context"
"crypto/sha256"
"encoding/hex"
"golang.org/x/crypto/bcrypt"
)
type encryptor struct {
cost int
generateFromPasswordFunc func([]byte, int) ([]byte, error)
compareHashAndPasswordFunc func([]byte, []byte) error
}
func New() Encryptor {
return &encryptor{
cost: bcrypt.DefaultCost,
generateFromPasswordFunc: bcrypt.GenerateFromPassword,
compareHashAndPasswordFunc: bcrypt.CompareHashAndPassword,
}
}
func (e *encryptor) EncryptSecret(_ context.Context, secret string) (string, error) {
res, err := e.generateFromPasswordFunc([]byte(secret), e.cost)
if err != nil {
return "", ErrFailedToEncryptPassword
}
return string(res), nil
}
func (e *encryptor) EncryptSecretUsingSum256(_ context.Context, secret string) (string, error) {
sum := sha256.Sum256([]byte(secret))
res, err := e.generateFromPasswordFunc([]byte(hex.EncodeToString(sum[:])), e.cost)
if err != nil {
return "", ErrFailedToEncryptPassword
}
return string(res), nil
}
func (e *encryptor) CompareHashAndSecret(_ context.Context, hash, password string) error {
err := e.compareHashAndPasswordFunc([]byte(hash), []byte(password))
if err != nil {
return ErrFailedToComparePasswords
}
return nil
}
func (e *encryptor) CompareHashAndSecretUsingSum256(_ context.Context, hash, password string) error {
sum := sha256.Sum256([]byte(password))
err := e.compareHashAndPasswordFunc([]byte(hash), []byte(hex.EncodeToString(sum[:])))
if err != nil {
return ErrFailedToComparePasswords
}
return nil
}
+8
View File
@@ -0,0 +1,8 @@
package encrypting
import "errors"
var (
ErrFailedToEncryptPassword = errors.New("failed to encrypt password")
ErrFailedToComparePasswords = errors.New("failed to compare passwords")
)
@@ -0,0 +1,12 @@
package encrypting
import "context"
type Encryptor interface {
EncryptSecretUsingArgon2id(ctx context.Context, secret string) (string, error)
CompareHashAndSecretUsingArgon2id(ctx context.Context, hash, secret string) error
EncryptSecret(ctx context.Context, secret string) (string, error)
EncryptSecretUsingSum256(_ context.Context, secret string) (string, error)
CompareHashAndSecret(ctx context.Context, hash, secret string) error
CompareHashAndSecretUsingSum256(ctx context.Context, hash, secret string) error
}
+164
View File
@@ -0,0 +1,164 @@
package migrator
import (
"context"
"io/fs"
"log/slog"
"github.com/jackc/pgx/v5"
"github.com/jackc/tern/v2/migrate"
"gitea.privcloud.tech/mtusi2026/internal/config"
"gitea.privcloud.tech/mtusi2026/internal/pkg/apperr"
"gitea.privcloud.tech/mtusi2026/migrations"
)
type Migrator interface {
MigrateUp(ctx context.Context) error
MigrateDown(ctx context.Context) error
MigrateTo(ctx context.Context, version int32) error
GetVersion(ctx context.Context) (int32, error)
Configure(ctx context.Context) error
Close(ctx context.Context) error
Start(ctx context.Context) error
Stop(ctx context.Context) error
}
type migrator struct {
cfg *config.Config
conn *pgx.Conn
migrator *migrate.Migrator
migrations fs.FS
configured bool
closed bool
}
func New(cfg *config.Config) Migrator {
return &migrator{
cfg: cfg,
conn: nil,
migrator: nil,
migrations: migrations.Migrations,
configured: false,
closed: false,
}
}
func (m *migrator) MigrateUp(ctx context.Context) error {
if !m.configured {
return apperr.New(apperr.CodeInternal, "migrator was not configured")
}
return m.migrator.Migrate(ctx)
}
func (m *migrator) MigrateDown(ctx context.Context) error {
if !m.configured {
return apperr.New(apperr.CodeInternal, "migrator was not configured")
}
return m.migrator.MigrateTo(ctx, 0)
}
func (m *migrator) MigrateTo(ctx context.Context, version int32) error {
if !m.configured {
return apperr.New(apperr.CodeInternal, "migrator was not configured")
}
return m.migrator.MigrateTo(ctx, version)
}
func (m *migrator) GetVersion(ctx context.Context) (int32, error) {
if !m.configured {
return -1, apperr.New(apperr.CodeInternal, "migrator was not configured")
}
return m.migrator.GetCurrentVersion(ctx)
}
func (m *migrator) Configure(ctx context.Context) error {
if err := m.initConn(ctx); err != nil {
return err
}
if err := m.initMigrator(ctx); err != nil {
return err
}
if err := m.loadMigrations(); err != nil {
return err
}
m.configured = true
return nil
}
func (m *migrator) Close(ctx context.Context) error {
if m.conn == nil || m.closed {
return nil
}
if err := m.closeConn(ctx); err != nil {
return err
}
m.closed = true
return nil
}
func (m *migrator) Start(ctx context.Context) error {
if !m.cfg.Postgres.GetRunMigrations() {
slog.Info("flag run migrations is disabled: skipping migrating")
return nil
}
err := m.Configure(ctx)
if err != nil {
slog.Error("failed to configure migrator", "error", err)
return err
}
err = m.MigrateUp(ctx)
if err != nil {
slog.Error("failed to migrate database up", "error", err)
return err
}
if err = m.Close(ctx); err != nil {
slog.Error("failed close connection to database", "error", err)
return err
}
m.closed = true
return nil
}
func (m *migrator) Stop(ctx context.Context) error {
return m.Close(ctx)
}
func (m *migrator) loadMigrations() (err error) {
err = m.migrator.LoadMigrations(m.migrations)
if err != nil {
slog.Error("failed to load migrations", "error", err)
return apperr.New(apperr.CodeInternal, "failed to load migrations")
}
slog.Info("successfully loaded migrations", "error", err)
return nil
}
func (m *migrator) initConn(ctx context.Context) (err error) {
m.closed = false
m.conn, err = pgx.Connect(ctx, m.cfg.Postgres.GetURI())
if err != nil {
slog.Error("failed to create connection to database", "error", err)
return apperr.New(apperr.CodeInternal, "failed to create connection to database")
}
slog.Info("connected to database", "db", m.cfg.Postgres.Database)
return nil
}
func (m *migrator) initMigrator(ctx context.Context) (err error) {
m.migrator, err = migrate.NewMigrator(ctx, m.conn, m.cfg.Postgres.GetVersionTableName())
if err != nil {
slog.Error("failed to initialize migrator", "error", err)
return apperr.New(apperr.CodeInternal, "failed to initialize migrator")
}
slog.Info("successfully initialized migrator")
return nil
}
func (m *migrator) closeConn(ctx context.Context) error {
return m.conn.Close(ctx)
}
@@ -0,0 +1,25 @@
package postgres
import (
"context"
"github.com/jackc/pgx/v5"
pgxUUID "github.com/vgarvardt/pgx-google-uuid/v5"
)
type AfterConnect func(ctx context.Context, conn *pgx.Conn) error
func AddUUIDSupport(_ context.Context, conn *pgx.Conn) error {
pgxUUID.Register(conn.TypeMap())
return nil
}
func WithEnumTypeSupport(enumName string) AfterConnect {
return func(ctx context.Context, conn *pgx.Conn) error {
dt, err := conn.LoadType(ctx, enumName)
if err != nil {
return err
}
conn.TypeMap().RegisterType(dt)
return nil
}
}
+7
View File
@@ -0,0 +1,7 @@
package postgres
type MigrationConfig interface {
GetURI() string
GetVersionTableName() string
GetRunMigrations() bool
}
+10
View File
@@ -0,0 +1,10 @@
package postgres
import (
"errors"
)
var (
errCreatingPool = errors.New("failed to create postgres pool")
errParseConfig = errors.New("failed to parse postgres config")
)
@@ -0,0 +1,15 @@
package postgres
import (
"context"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
)
type Conn interface {
SendBatch(ctx context.Context, b *pgx.Batch) pgx.BatchResults
Exec(ctx context.Context, sql string, arguments ...any) (commandTag pgconn.CommandTag, err error)
Query(ctx context.Context, sql string, args ...any) (pgx.Rows, error)
QueryRow(ctx context.Context, sql string, args ...any) pgx.Row
}
+95
View File
@@ -0,0 +1,95 @@
package postgres
import (
"context"
"log/slog"
"strconv"
"time"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgxpool"
"github.com/jackc/pgx/v5/tracelog"
pgxslog "github.com/mcosta74/pgx-slog"
)
type ConfigWithLog interface {
GetLogLevel() string
}
type ConfigWithTimeouts interface {
GetConnectTimeout() time.Duration
GetQueryTimeout() time.Duration
}
type ConfigWithMaxConn interface {
GetMaxConnections() int32
}
func getLevelFromConfig(cfg MigrationConfig) tracelog.LogLevel {
if logCfg, ok := cfg.(ConfigWithLog); ok {
lvl, _ := tracelog.LogLevelFromString(logCfg.GetLogLevel())
return lvl
}
return tracelog.LogLevelError
}
func addMaxConnectionsToCfg(cfg any, poolCfg *pgxpool.Config) {
if connCfg, ok := cfg.(ConfigWithMaxConn); ok {
poolCfg.MaxConns = connCfg.GetMaxConnections()
}
}
func New(cfg MigrationConfig, afterConnect ...AfterConnect) *pgxpool.Pool {
lvl := getLevelFromConfig(cfg)
if len(afterConnect) == 0 {
afterConnect = []AfterConnect{AddUUIDSupport}
}
poolConfig, err := pgxpool.ParseConfig(cfg.GetURI())
if err != nil {
slog.Error("failed to parse postgres config", "error", err)
panic(err)
}
addMaxConnectionsToCfg(cfg, poolConfig)
if timeoutCfg, ok := cfg.(ConfigWithTimeouts); ok {
poolConfig.ConnConfig.ConnectTimeout = timeoutCfg.GetConnectTimeout()
poolConfig.ConnConfig.RuntimeParams["statement_timeout"] = strconv.FormatInt(timeoutCfg.GetQueryTimeout().Milliseconds(), 10)
}
poolConfig.ConnConfig.RuntimeParams["application_name"] = "mtusi-api"
slog.Info("postgres_pool_config", "max_conns", poolConfig.MaxConns,
"connect_timeout", poolConfig.ConnConfig.ConnectTimeout,
"statement_timeout_ms", poolConfig.ConnConfig.RuntimeParams["statement_timeout"])
poolConfig.ConnConfig.Tracer = &tracelog.TraceLog{
Logger: pgxslog.NewLogger(slog.Default()),
LogLevel: lvl,
Config: &tracelog.TraceLogConfig{
TimeKey: "ts",
},
}
poolConfig.AfterConnect = load(afterConnect...)
pool, err := pgxpool.NewWithConfig(context.Background(), poolConfig)
if err != nil {
slog.Error("failed to create postgres pool", "error", err)
panic(err)
}
slog.Info("successfully connected to postgres pool")
return pool
}
func load(afterConnects ...AfterConnect) func(ctx context.Context, conn *pgx.Conn) error {
return func(ctx context.Context, conn *pgx.Conn) error {
for _, afterConnect := range afterConnects {
if err := afterConnect(ctx, conn); err != nil {
return err
}
}
return nil
}
}
@@ -0,0 +1,59 @@
package txmanager
import (
"context"
"errors"
"fmt"
"log/slog"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgxpool"
)
type TransactionManager struct {
pool *pgxpool.Pool
}
func New(pool *pgxpool.Pool) *TransactionManager {
return &TransactionManager{
pool: pool,
}
}
func (tm *TransactionManager) RunInTransaction(ctx context.Context, opts *pgx.TxOptions, fn func(tx pgx.Tx) error) (err error) {
var tx pgx.Tx
if opts != nil {
tx, err = tm.pool.BeginTx(ctx, *opts)
} else {
tx, err = tm.pool.Begin(ctx)
}
if err != nil {
return fmt.Errorf("failed to begin transaction: %w", err)
}
var committed bool
defer func() {
if p := recover(); p != nil {
err = fmt.Errorf("panic in transaction: %v", p)
}
if !committed {
rollbackErr := tx.Rollback(ctx)
if rollbackErr != nil && !errors.Is(rollbackErr, pgx.ErrTxClosed) {
slog.Error("failed to rollback transaction", "error", rollbackErr)
}
}
}()
if err = fn(tx); err != nil {
return fmt.Errorf("failed to execute transaction: %w", err)
}
if err = tx.Commit(ctx); err != nil {
return fmt.Errorf("failed to commit transaction: %w", err)
}
committed = true
return nil
}
@@ -0,0 +1,248 @@
package framework
import (
"context"
"encoding/json"
"errors"
"fmt"
"io"
"log/slog"
"mime"
"net/http"
"strconv"
"strings"
"github.com/go-chi/chi/v5"
v10 "github.com/go-playground/validator/v10"
"github.com/google/uuid"
"gitea.privcloud.tech/mtusi2026/internal/dto"
"gitea.privcloud.tech/mtusi2026/internal/gen/contracts"
"gitea.privcloud.tech/mtusi2026/internal/pkg/apperr"
"gitea.privcloud.tech/mtusi2026/internal/pkg/auth/jwtprovider"
"gitea.privcloud.tech/mtusi2026/internal/pkg/rest/headers"
"gitea.privcloud.tech/mtusi2026/internal/pkg/validator"
)
func validate(ctx context.Context, v *validator.ValidatorImpl, value any) error {
err := v.ValidateCtx(ctx, value)
if err == nil {
return nil
}
var fieldErrors v10.ValidationErrors
if errors.As(err, &fieldErrors) {
return apperr.Wrap(err, apperr.CodeValidation, "invalid request fields")
}
return apperr.Wrap(err, apperr.CodeInternal, "validation failed")
}
func Validate(w http.ResponseWriter, r *http.Request, v *validator.ValidatorImpl, value any) bool {
if err := validate(r.Context(), v, value); err != nil {
JSONError(r.Context(), w, err)
return false
}
return true
}
func JSONResponse(w http.ResponseWriter, status int, body any) {
w.Header().Set(headers.HeaderContentType, "application/json")
w.WriteHeader(status)
if status == http.StatusNoContent {
return
}
if err := json.NewEncoder(w).Encode(body); err != nil {
wrapped := apperr.Wrap(err, apperr.CodeInternal, "failed json encode")
slog.Error("response", "error", wrapped)
}
}
func JSONError(ctx context.Context, w http.ResponseWriter, err error) {
if err == nil {
return
}
requestId, ok := ctx.Value(headers.HeaderRequestID).(uuid.UUID)
if !ok {
requestId = uuid.New()
}
w.Header().Set(headers.HeaderRequestID, requestId.String())
if errors.Is(err, context.DeadlineExceeded) {
err = apperr.Wrap(err, apperr.CodeServiceUnavailable, "request deadline exceeded")
}
appErr := apperr.As(err)
if appErr == nil {
appErr = apperr.As(apperr.New(apperr.CodeInternal, "internal server error"))
}
if appErr.Code().HTTPStatus() == http.StatusUnauthorized && w.Header().Get("WWW-Authenticate") == "" {
w.Header().Set("WWW-Authenticate", `Bearer realm="messenger"`)
}
slog.Error("response", "error", err, "status", appErr.Code().HTTPStatus(), "requestId", requestId.String())
var code contracts.ErrorErrorCode
switch appErr.Code() {
case apperr.CodeBadRequest, apperr.CodeValidation:
code = contracts.InvalidRequest
case apperr.CodeUnauthorized:
code = contracts.Unauthorized
case apperr.CodeNotFound:
code = contracts.NotFound
case apperr.CodeAlreadyExists, apperr.CodeConflict:
code = contracts.Conflict
case apperr.CodePayloadTooLarge:
code = contracts.PayloadTooLarge
case apperr.CodeTooManyRequests:
code = contracts.RateLimited
case apperr.CodeServiceUnavailable, apperr.CodeUnavailable:
code = contracts.Unavailable
case apperr.CodeUnsupportedMediaType:
code = contracts.UnsupportedMediaType
default:
code = contracts.InternalError
}
JSONResponse(w, appErr.Code().HTTPStatus(), contracts.Error{
Error: struct {
Code contracts.ErrorErrorCode `json:"code"`
Message string `json:"message"`
RequestId string `json:"request_id"`
}{
Code: code,
Message: appErr.Message(),
RequestId: requestId.String(),
},
})
}
func Decode(w http.ResponseWriter, r *http.Request, object any) bool {
mediaType, params, err := mime.ParseMediaType(r.Header.Get(headers.HeaderContentType))
if err != nil || mediaType != "application/json" ||
(params["charset"] != "" && !strings.EqualFold(params["charset"], "utf-8")) {
JSONError(r.Context(), w, apperr.New(apperr.CodeUnsupportedMediaType, "expected application/json"))
return false
}
decoder := json.NewDecoder(r.Body)
decoder.DisallowUnknownFields()
if err := decoder.Decode(object); err != nil {
JSONError(r.Context(), w, apperr.Wrap(err, apperr.CodeBadRequest, "failed decode"))
return false
}
var trailing any
if err := decoder.Decode(&trailing); err != io.EOF {
JSONError(r.Context(), w, apperr.New(apperr.CodeBadRequest, "expected one JSON object"))
return false
}
return true
}
func PathParam(r *http.Request, key string) string {
return chi.URLParam(r, key)
}
func QueryParam(r *http.Request, key string) string {
return r.URL.Query().Get(key)
}
func HeaderParam(r *http.Request, key string) string {
return r.Header.Get(key)
}
func ParseIDFromPathParam(ctx context.Context, w http.ResponseWriter, r *http.Request, key string) (uuid.UUID, error) {
rawID := PathParam(r, key)
id, err := uuid.Parse(rawID)
if err != nil {
JSONError(ctx, w, apperr.New(apperr.CodeValidation, fmt.Sprintf("provided invalid %s", key)))
return uuid.Nil, err
}
return id, nil
}
func ParseIDFromQueryParam(ctx context.Context, w http.ResponseWriter, r *http.Request, key string) (uuid.UUID, error) {
rawID := QueryParam(r, key)
id, err := uuid.Parse(rawID)
if err != nil {
JSONError(ctx, w, apperr.New(apperr.CodeValidation, fmt.Sprintf("provided invalid %s", key)))
return uuid.Nil, err
}
return id, nil
}
func ParseIDFromHeaderParam(ctx context.Context, w http.ResponseWriter, r *http.Request, key string) (uuid.UUID, error) {
rawID := HeaderParam(r, key)
id, err := uuid.Parse(rawID)
if err != nil {
JSONError(ctx, w, apperr.New(apperr.CodeUnauthorized, "missing or invalid user ID"))
return uuid.Nil, err
}
return id, nil
}
func Header(r *http.Request, header string) (string, bool) {
return r.Header.Get(header), r.Header.Get(header) != ""
}
func Token(r *http.Request) (string, bool) {
foundHeader := r.Header.Get(headers.HeaderAuthorization)
if foundHeader == "" {
return "", false
}
token, found := strings.CutPrefix(foundHeader, "Bearer ")
if !found {
return "", false
}
return token, true
}
func ParseToken(r *http.Request, provider jwtprovider.Provider) (*dto.UserDataInToken, error) {
foundHeader := r.Header.Get(headers.HeaderAuthorization)
if foundHeader == "" {
return nil, apperr.New(apperr.CodeUnauthorized, "missing authorization header")
}
token, found := strings.CutPrefix(foundHeader, "Bearer ")
if !found {
return nil, apperr.New(apperr.CodeUnauthorized, "invalid authorization header")
}
userData, err := provider.ParseVerified(&dto.Token{Payload: token})
if err != nil {
return nil, apperr.Wrap(err, apperr.CodeUnauthorized, "invalid token")
}
return userData, nil
}
func PageParams(w http.ResponseWriter, r *http.Request) (*int, *uuid.UUID, bool) {
query := r.URL.Query()
var limit *int
if values, exists := query["limit"]; exists {
if len(values) != 1 {
JSONError(r.Context(), w, apperr.New(apperr.CodeBadRequest, "invalid limit"))
return nil, nil, false
}
value, err := strconv.Atoi(values[0])
if err != nil || value < 1 || value > 100 {
JSONError(r.Context(), w, apperr.New(apperr.CodeBadRequest, "invalid limit"))
return nil, nil, false
}
limit = &value
}
var afterID *uuid.UUID
if values, exists := query["cursor"]; exists {
if len(values) != 1 {
JSONError(r.Context(), w, apperr.New(apperr.CodeBadRequest, "invalid cursor"))
return nil, nil, false
}
id, err := uuid.Parse(values[0])
if err != nil || id == uuid.Nil {
JSONError(r.Context(), w, apperr.New(apperr.CodeBadRequest, "invalid cursor"))
return nil, nil, false
}
afterID = &id
}
return limit, afterID, true
}
@@ -0,0 +1,8 @@
package headers
const (
HeaderContentType = "Content-Type"
HeaderRequestID = "X-Request-Id"
HeaderUserID = "X-User-Id"
HeaderAuthorization = "Authorization"
)
@@ -0,0 +1,74 @@
package middleware
import (
"context"
"net/http"
"gitea.privcloud.tech/mtusi2026/internal/dto"
"gitea.privcloud.tech/mtusi2026/internal/pkg/apperr"
"gitea.privcloud.tech/mtusi2026/internal/pkg/rest/framework"
"gitea.privcloud.tech/mtusi2026/internal/pkg/types/role"
)
var _ AuthMiddleware = (*authMiddleware)(nil)
type AuthMiddleware interface {
WithPrivateAccess(next http.Handler) http.Handler
WithAdminAccess(next http.Handler) http.Handler
}
type SessionVerifier interface {
VerifySession(ctx context.Context, token dto.Token) (*dto.UserDataInToken, error)
}
type authMiddleware struct {
verifier SessionVerifier
}
func NewAuthMiddleware(verifier SessionVerifier) AuthMiddleware {
return &authMiddleware{verifier: verifier}
}
func (a *authMiddleware) WithPrivateAccess(next http.Handler) http.Handler {
return a.privateAccessCheckCallback(next)
}
func (a *authMiddleware) WithAdminAccess(next http.Handler) http.Handler {
return a.operatorAccessCheckCallback(role.Admin, next)
}
func (a *authMiddleware) privateAccessCheckCallback(next http.Handler) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
if _, err := a.verifySession(r); err != nil {
framework.JSONError(r.Context(), w, err)
return
}
next.ServeHTTP(w, r)
}
}
func (a *authMiddleware) operatorAccessCheckCallback(expectedRole role.Role, next http.Handler) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
u, err := a.verifySession(r)
if err != nil {
framework.JSONError(r.Context(), w, err)
return
}
if u.Role != role.Admin && u.Role != expectedRole {
framework.JSONError(r.Context(), w, apperr.New(apperr.CodeForbidden, "insufficient permissions"))
return
}
next.ServeHTTP(w, r)
}
}
func (a *authMiddleware) verifySession(r *http.Request) (*dto.UserDataInToken, error) {
token, found := framework.Token(r)
if !found || token == "" {
return nil, apperr.New(apperr.CodeUnauthorized, "missing or invalid bearer token")
}
return a.verifier.VerifySession(r.Context(), dto.Token{Payload: token})
}
@@ -0,0 +1,34 @@
package middleware
import (
"log/slog"
"net/http"
"time"
"github.com/go-chi/chi/v5/middleware"
"gitea.privcloud.tech/mtusi2026/internal/pkg/rest/headers"
)
func LoggingMiddleware() Middleware {
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
started := time.Now()
wrapped := middleware.NewWrapResponseWriter(w, r.ProtoMajor)
next.ServeHTTP(wrapped, r)
status := wrapped.Status()
if status == 0 {
status = http.StatusOK
}
slog.InfoContext(r.Context(), "http request",
"method", r.Method,
"path", r.URL.Path,
"status", status,
"duration", time.Since(started),
"bytes", wrapped.BytesWritten(),
"request_id", w.Header().Get(headers.HeaderRequestID),
)
})
}
}
@@ -0,0 +1,5 @@
package middleware
import "net/http"
type Middleware = func(http.Handler) http.Handler
@@ -0,0 +1,22 @@
package middleware
import (
"context"
"net/http"
"github.com/google/uuid"
"gitea.privcloud.tech/mtusi2026/internal/pkg/rest/headers"
)
func RequestIDMiddleware() Middleware {
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
requestID := uuid.New()
w.Header().Set(headers.HeaderRequestID, requestID.String())
ctx = context.WithValue(ctx, headers.HeaderRequestID, requestID)
next.ServeHTTP(w, r.WithContext(ctx))
})
}
}
@@ -0,0 +1,18 @@
package middleware
import (
"context"
"net/http"
"time"
)
// RequestTimeout bounds database work and waiting for a pooled connection.
func RequestTimeout(timeout time.Duration) Middleware {
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
ctx, cancel := context.WithTimeout(r.Context(), timeout)
defer cancel()
next.ServeHTTP(w, r.WithContext(ctx))
})
}
}
+131
View File
@@ -0,0 +1,131 @@
package router
import (
"net/http"
"github.com/go-chi/chi/v5"
"gitea.privcloud.tech/mtusi2026/internal/pkg/rest/middleware"
)
type Router interface {
Private(method, pattern string, handler http.HandlerFunc, mw ...func(http.Handler) http.Handler)
Public(method, pattern string, handler http.HandlerFunc, mw ...func(http.Handler) http.Handler)
Admin(method, pattern string, handler http.HandlerFunc, mw ...func(http.Handler) http.Handler)
ServeHTTP(w http.ResponseWriter, r *http.Request)
With(mw ...func(http.Handler) http.Handler) Router
Use(mw ...func(http.Handler) http.Handler) Router
Handle(pattern string, handler http.Handler)
Get(pattern string, handler http.HandlerFunc)
Head(pattern string, handler http.HandlerFunc)
Options(pattern string, handler http.HandlerFunc)
Post(pattern string, handler http.HandlerFunc)
Put(pattern string, handler http.HandlerFunc)
Patch(pattern string, handler http.HandlerFunc)
Delete(pattern string, handler http.HandlerFunc)
Connect(pattern string, handler http.HandlerFunc)
Trace(pattern string, handler http.HandlerFunc)
}
type router struct {
r chi.Router
jwtMw middleware.AuthMiddleware
}
func New(jwtMw middleware.AuthMiddleware, mw ...middleware.Middleware) Router {
r := chi.NewRouter()
r.Use(mw...)
return &router{
r: r,
jwtMw: jwtMw,
}
}
func (c *router) Group(pattern string) Router {
sub := &router{
r: chi.NewRouter(),
jwtMw: c.jwtMw,
}
c.r.Mount(pattern, sub.r)
return sub
}
func (c *router) Public(method, pattern string, handler http.HandlerFunc, mw ...func(http.Handler) http.Handler) {
next := c.applyMiddlewares(handler, mw...)
c.r.MethodFunc(method, pattern, next.ServeHTTP)
}
func (c *router) Private(method, pattern string, handler http.HandlerFunc, mw ...func(http.Handler) http.Handler) {
next := c.applyMiddlewares(handler, mw...)
c.r.MethodFunc(method, pattern, (c.jwtMw.WithPrivateAccess(next)).ServeHTTP)
}
func (c *router) Admin(method, pattern string, handler http.HandlerFunc, mw ...func(http.Handler) http.Handler) {
next := c.applyMiddlewares(handler, mw...)
c.r.MethodFunc(method, pattern, (c.jwtMw.WithAdminAccess(next)).ServeHTTP)
}
func (c *router) ServeHTTP(w http.ResponseWriter, r *http.Request) {
c.r.ServeHTTP(w, r)
}
func (c *router) With(mw ...func(http.Handler) http.Handler) Router {
sub := &router{
r: c.r.With(mw...),
jwtMw: c.jwtMw,
}
return sub
}
func (c *router) Use(mw ...func(http.Handler) http.Handler) Router {
c.r.Use(mw...)
return c
}
func (c *router) Handle(pattern string, handler http.Handler) {
c.r.Handle(pattern, handler)
}
func (c *router) Get(pattern string, handler http.HandlerFunc) {
c.r.Get(pattern, handler)
}
func (c *router) Head(pattern string, handler http.HandlerFunc) {
c.r.Head(pattern, handler)
}
func (c *router) Options(pattern string, handler http.HandlerFunc) {
c.r.Options(pattern, handler)
}
func (c *router) Post(pattern string, handler http.HandlerFunc) {
c.r.Post(pattern, handler)
}
func (c *router) Put(pattern string, handler http.HandlerFunc) {
c.r.Put(pattern, handler)
}
func (c *router) Patch(pattern string, handler http.HandlerFunc) {
c.r.Patch(pattern, handler)
}
func (c *router) Delete(pattern string, handler http.HandlerFunc) {
c.r.Delete(pattern, handler)
}
func (c *router) Connect(pattern string, handler http.HandlerFunc) {
c.r.Connect(pattern, handler)
}
func (c *router) Trace(pattern string, handler http.HandlerFunc) {
c.r.Trace(pattern, handler)
}
func (c *router) applyMiddlewares(handler http.HandlerFunc, mw ...func(http.Handler) http.Handler) http.Handler {
next := http.Handler(handler)
for _, mwFunc := range mw {
next = mwFunc(next)
}
return next
}
@@ -0,0 +1,82 @@
package authprovider
import (
"encoding/json"
"strings"
"gitea.privcloud.tech/mtusi2026/internal/pkg/types"
)
type Type string
const (
TypeUndefined Type = "undefined"
TypePassword Type = "password"
TypeEmail Type = "email"
TypePhone Type = "phone"
TypeGoogle Type = "google"
TypeTelegram Type = "telegram"
)
var allowedTypes = map[Type]struct{}{
TypePassword: {},
TypeEmail: {},
TypePhone: {},
TypeGoogle: {},
TypeTelegram: {},
}
func ParseType(value string) Type {
t := Type(strings.ToLower(value))
if !t.IsValid() {
return TypeUndefined
}
return t
}
func ParseAndValidateType(value string) (Type, error) {
parsed := ParseType(value)
if _, ok := allowedTypes[parsed]; ok {
return parsed, nil
}
return TypeUndefined, types.ErrUnsupportedOTPStatus
}
func (t Type) String() string {
return string(t)
}
func (t Type) Validate() error {
if _, ok := allowedTypes[t]; ok {
return nil
}
return types.ErrUnsupportedAuthProviderType
}
func (t Type) IsValid() bool {
_, ok := allowedTypes[t]
return ok
}
func (t Type) MarshalJSON() ([]byte, error) {
if err := t.Validate(); err != nil {
return nil, err
}
return json.Marshal(t.String())
}
func (t *Type) UnmarshalJSON(data []byte) error {
if t == nil {
return types.ErrUnmarshalAuthProviderTypeIntoNilPointer
}
var value string
if err := json.Unmarshal(data, &value); err != nil {
return err
}
parsed := ParseType(value)
if err := parsed.Validate(); err != nil {
return err
}
*t = parsed
return nil
}
@@ -0,0 +1,77 @@
package environment
import (
"encoding/json"
"strings"
"gitea.privcloud.tech/mtusi2026/internal/pkg/types"
)
type ApplicationEnvironment string
const (
ApplicationEnvironmentUndefined ApplicationEnvironment = "undefined"
ApplicationEnvironmentDev ApplicationEnvironment = "dev"
ApplicationEnvironmentProd ApplicationEnvironment = "prod"
)
var allowedEnvironments = map[ApplicationEnvironment]struct{}{
ApplicationEnvironmentUndefined: {},
ApplicationEnvironmentDev: {},
ApplicationEnvironmentProd: {},
}
func ParseEnvironment(value string) ApplicationEnvironment {
s := ApplicationEnvironment(strings.ToLower(value))
if !s.IsValid() {
return ApplicationEnvironmentUndefined
}
return s
}
func ParseAndValidateEnvironment(status string) (ApplicationEnvironment, error) {
parsed := ParseEnvironment(status)
if _, ok := allowedEnvironments[parsed]; ok {
return parsed, nil
}
return ApplicationEnvironmentUndefined, types.ErrUnsupportedApplicationEnvironment
}
func (t ApplicationEnvironment) String() string {
return string(t)
}
func (t ApplicationEnvironment) Validate() error {
if _, ok := allowedEnvironments[t]; ok {
return nil
}
return types.ErrUnsupportedApplicationEnvironment
}
func (t ApplicationEnvironment) IsValid() bool {
_, ok := allowedEnvironments[t]
return ok
}
func (t ApplicationEnvironment) MarshalJSON() ([]byte, error) {
if err := t.Validate(); err != nil {
return nil, err
}
return json.Marshal(t.String())
}
func (t *ApplicationEnvironment) UnmarshalJSON(data []byte) error {
if t == nil {
return types.ErrUnmarshalApplicationEnvironmentIntoNilPointer
}
var value string
if err := json.Unmarshal(data, &value); err != nil {
return err
}
parsed := ParseEnvironment(value)
if err := parsed.Validate(); err != nil {
return err
}
*t = parsed
return nil
}
+25
View File
@@ -0,0 +1,25 @@
package types
import "errors"
var (
ErrUnsupportedRole = errors.New("unsupported role")
ErrUnsupportedOTPType = errors.New("unsupported OTP type")
ErrUnsupportedAuthProviderType = errors.New("unsupported auth provider type")
ErrUnsupportedContactType = errors.New("unsupported contact type")
ErrUnsupportedOTPStatus = errors.New("unsupported OTP status")
ErrUnsupportedOTPResult = errors.New("unsupported OTP result")
ErrUnsupportedFormStatus = errors.New("unsupported form status")
ErrUnsupportedAuthIdentityStatus = errors.New("unsupported auth identity status")
ErrUnsupportedApplicationEnvironment = errors.New("unsupported application environment")
ErrUnmarshalRoleIntoNilPointer = errors.New("unmarshal role into nil pointer")
ErrUnmarshalOTPTypeIntoNilPointer = errors.New("unmarshal OTP type into nil pointer")
ErrUnmarshalAuthProviderTypeIntoNilPointer = errors.New("unmarshal auth provider into nil pointer")
ErrUnmarshalContactTypeIntoNilPointer = errors.New("unmarshal contact into nil pointer")
ErrUnmarshalOTPStatusIntoNilPointer = errors.New("unmarshal OTP status into nil pointer")
ErrUnmarshalOTPResultIntoNilPointer = errors.New("unmarshal OTP result into nil pointer")
ErrUnmarshalFormStatusIntoNilPointer = errors.New("unmarshal form status into nil pointer")
ErrUnmarshalAuthIdentityStatusIntoNilPointer = errors.New("unmarshal auth identity status into nil pointer")
ErrUnmarshalApplicationEnvironmentIntoNilPointer = errors.New("unmarshal application environment into nil pointer")
)
+105
View File
@@ -0,0 +1,105 @@
package role
import (
"encoding/json"
"strings"
"gitea.privcloud.tech/mtusi2026/internal/pkg/types"
)
type Role string
const (
Undefined Role = "undefined"
User Role = "user"
Doctor Role = "doctor"
Manager Role = "manager"
Admin Role = "admin"
)
var allowedRoles = map[Role]struct{}{
User: {},
Doctor: {},
Manager: {},
Admin: {},
}
func ParseRole(s string) Role {
r := Role(strings.ToLower(s))
if !r.IsValid() {
return Undefined
}
return r
}
func ParseAndValidateRole(s string) (Role, error) {
parsed := ParseRole(s)
if _, ok := allowedRoles[parsed]; ok {
return parsed, nil
}
return Undefined, types.ErrUnsupportedRole
}
func (t Role) String() string {
return string(t)
}
func (t Role) Validate() error {
if _, ok := allowedRoles[t]; ok {
return nil
}
return types.ErrUnsupportedRole
}
func (t Role) IsValid() bool {
_, ok := allowedRoles[t]
return ok
}
func (t Role) MarshalJSON() ([]byte, error) {
if err := t.Validate(); err != nil {
return nil, err
}
return json.Marshal(t.String())
}
func (t *Role) UnmarshalJSON(data []byte) error {
if t == nil {
return types.ErrUnmarshalRoleIntoNilPointer
}
var value string
if err := json.Unmarshal(data, &value); err != nil {
return err
}
parsed := ParseRole(value)
if err := parsed.Validate(); err != nil {
return err
}
*t = parsed
return nil
}
func (t Role) IsAdmin() bool {
return t == Admin
}
func (t Role) IsManager() bool {
return t == Manager
}
func (t Role) IsDoctor() bool {
return t == Doctor
}
func (t Role) IsUser() bool {
return t == User
}
func (t Role) IsPrivileged() bool {
switch t {
case Doctor, Manager, Admin:
return true
default:
return false
}
}
@@ -0,0 +1,29 @@
package validator
import (
"context"
"github.com/go-playground/validator/v10"
)
type TagKey string
type ValidatorImpl struct {
validator *validator.Validate
}
func NewValidatorImpl() *ValidatorImpl {
return &ValidatorImpl{validator: validator.New()}
}
func (v *ValidatorImpl) Register(tag TagKey, fn validator.Func, callValidationEvenIfNull ...bool) error {
return v.validator.RegisterValidation(string(tag), fn, callValidationEvenIfNull...)
}
func (v *ValidatorImpl) ValidateCtx(ctx context.Context, value any) error {
return v.validator.StructCtx(ctx, value)
}
func (v *ValidatorImpl) Validate(value any) error {
return v.validator.Struct(value)
}
+15
View File
@@ -0,0 +1,15 @@
package auth
import (
"context"
"gitea.privcloud.tech/mtusi2026/internal/dto"
)
type API interface {
Login(ctx context.Context, req dto.Login) (*dto.LoginResult, error)
VerifyAccessToken(ctx context.Context, req dto.Token) (*dto.UserDataInToken, error)
VerifySession(ctx context.Context, token dto.Token) (*dto.UserDataInToken, error)
RefreshTokens(ctx context.Context, req dto.RefreshToken) (*dto.Tokens, error)
Logout(ctx context.Context, req dto.RefreshToken) error
}
@@ -0,0 +1,21 @@
package auth
import (
"context"
"github.com/google/uuid"
"github.com/jackc/pgx/v5"
"gitea.privcloud.tech/mtusi2026/internal/dto"
)
type userRepo interface {
GetCredentialsByUsername(ctx context.Context, username string) (*dto.UserCredentials, error)
}
type refreshTokensRepo interface {
GetByID(ctx context.Context, id uuid.UUID) (*dto.StoredRefreshToken, error)
GetByIDForUpdateTx(ctx context.Context, tx pgx.Tx, id uuid.UUID) (*dto.StoredRefreshToken, error)
CreateTx(ctx context.Context, tx pgx.Tx, req dto.StoredRefreshToken) error
RevokeTx(ctx context.Context, tx pgx.Tx, req dto.RevokeRefreshToken) error
}
+267
View File
@@ -0,0 +1,267 @@
package auth
import (
"context"
"time"
"github.com/google/uuid"
"github.com/jackc/pgx/v5"
"gitea.privcloud.tech/mtusi2026/internal/dto"
"gitea.privcloud.tech/mtusi2026/internal/pkg/apperr"
"gitea.privcloud.tech/mtusi2026/internal/pkg/auth/jwtprovider"
"gitea.privcloud.tech/mtusi2026/internal/pkg/encrypting"
"gitea.privcloud.tech/mtusi2026/internal/pkg/postgres/txmanager"
"gitea.privcloud.tech/mtusi2026/internal/pkg/types/role"
)
var _ API = (*Auth)(nil)
type Auth struct {
jwt jwtprovider.Provider
tm *txmanager.TransactionManager
encryptor encrypting.Encryptor
usersRepo userRepo
refreshTokensRepo refreshTokensRepo
}
func New(
jwt jwtprovider.Provider,
tm *txmanager.TransactionManager,
encryptor encrypting.Encryptor,
usersRepo userRepo,
refreshTokensRepo refreshTokensRepo,
) *Auth {
return &Auth{
jwt: jwt,
tm: tm,
encryptor: encryptor,
usersRepo: usersRepo,
refreshTokensRepo: refreshTokensRepo,
}
}
func (a *Auth) Login(ctx context.Context, req dto.Login) (*dto.LoginResult, error) {
if req.Username == "" || req.Password == "" {
return nil, apperr.New(apperr.CodeUnauthorized, "invalid credentials")
}
credentials, err := a.usersRepo.GetCredentialsByUsername(ctx, req.Username)
if err != nil {
if apperr.CodeFromError(err) == apperr.CodeNotFound {
return nil, apperr.New(apperr.CodeUnauthorized, "invalid credentials")
}
return nil, err
}
if err = a.encryptor.CompareHashAndSecretUsingArgon2id(ctx, credentials.PasswordHash, req.Password); err != nil {
if ctx.Err() != nil {
return nil, ctx.Err()
}
return nil, apperr.New(apperr.CodeUnauthorized, "invalid credentials")
}
var (
tokens *dto.Tokens
data *dto.UserDataInToken
)
err = a.tm.RunInTransaction(ctx, nil, func(tx pgx.Tx) error {
tokens, err = a.jwt.CreateRefreshAndAccessTokensForUser(credentials.User.ID, role.User)
if err != nil {
return apperr.Wrap(err, apperr.CodeInternal, "failed to generate tokens")
}
data, err = a.verifyToken(tokens.RefreshToken.Token(), false)
if err != nil {
return apperr.Wrap(err, apperr.CodeInternal, "failed to validate generated refresh token")
}
var hash string
hash, err = a.encryptor.EncryptSecretUsingSum256(ctx, tokens.RefreshToken.Payload)
if err != nil {
return apperr.Wrap(err, apperr.CodeInternal, "failed to hash refresh token")
}
stored := dto.StoredRefreshToken{
ID: data.TokenID,
UserID: data.UserID,
TokenHash: hash,
Role: data.Role,
ExpiresAt: data.ExpiresAt,
CreatedAt: data.IssuedAt,
}
if err = a.refreshTokensRepo.CreateTx(ctx, tx, stored); err != nil {
return err
}
return nil
})
if err != nil {
return nil, err
}
return &dto.LoginResult{
ExpiresAt: data.ExpiresAt,
TokenType: "Bearer",
User: credentials.User,
Tokens: *tokens,
}, nil
}
func (a *Auth) VerifyAccessToken(ctx context.Context, req dto.Token) (*dto.UserDataInToken, error) {
if err := ctx.Err(); err != nil {
return nil, err
}
return a.verifyToken(&req, true)
}
func (a *Auth) VerifySession(ctx context.Context, token dto.Token) (*dto.UserDataInToken, error) {
if err := ctx.Err(); err != nil {
return nil, err
}
data, err := a.verifyTokenClaims(&token)
if err != nil {
return nil, err
}
if data.IsAccess {
return nil, apperr.New(apperr.CodeUnauthorized, "invalid session token")
}
stored, err := a.refreshTokensRepo.GetByID(ctx, data.TokenID)
if err != nil {
if apperr.CodeFromError(err) == apperr.CodeNotFound {
return nil, apperr.New(apperr.CodeUnauthorized, "invalid session")
}
return nil, err
}
if err = a.validateStoredSession(ctx, token, data, stored); err != nil {
return nil, err
}
return data, nil
}
func (a *Auth) Logout(ctx context.Context, req dto.RefreshToken) error {
data, err := a.verifyToken(req.Token(), false)
if err != nil {
return err
}
return a.tm.RunInTransaction(ctx, nil, func(tx pgx.Tx) error {
stored, err := a.activeRefreshTokenTx(ctx, tx, req, data)
if err != nil {
return err
}
return a.refreshTokensRepo.RevokeTx(ctx, tx, dto.RevokeRefreshToken{
ID: stored.ID,
RevokedAt: time.Now(),
})
})
}
func (a *Auth) RefreshTokens(ctx context.Context, req dto.RefreshToken) (*dto.Tokens, error) {
data, err := a.verifyToken(req.Token(), false)
if err != nil {
return nil, err
}
var tokens *dto.Tokens
err = a.tm.RunInTransaction(ctx, nil, func(tx pgx.Tx) error {
stored, err := a.activeRefreshTokenTx(ctx, tx, req, data)
if err != nil {
return err
}
if err = a.refreshTokensRepo.RevokeTx(ctx, tx, dto.RevokeRefreshToken{
ID: stored.ID,
RevokedAt: time.Now(),
}); err != nil {
return err
}
tokens, err = a.createTokensTx(ctx, tx, stored.UserID, stored)
return err
})
if err != nil {
return nil, err
}
return tokens, nil
}
func (a *Auth) verifyToken(token *dto.Token, isAccess bool) (*dto.UserDataInToken, error) {
data, err := a.verifyTokenClaims(token)
if err != nil {
return nil, err
}
if data.IsAccess != isAccess || data.Role != role.User {
return nil, apperr.New(apperr.CodeUnauthorized, "invalid token")
}
return data, nil
}
func (a *Auth) verifyTokenClaims(token *dto.Token) (*dto.UserDataInToken, error) {
data, err := a.jwt.ParseVerified(token)
if err != nil {
return nil, apperr.Wrap(err, apperr.CodeUnauthorized, "invalid token")
}
if err = data.Validate(); err != nil {
return nil, apperr.Wrap(err, apperr.CodeUnauthorized, "invalid token claims")
}
now := time.Now()
if data.IssuedAt.After(now) || !data.ExpiresAt.After(now) {
return nil, apperr.New(apperr.CodeUnauthorized, "invalid token")
}
return data, nil
}
func (a *Auth) activeRefreshTokenTx(ctx context.Context, tx pgx.Tx, token dto.RefreshToken, data *dto.UserDataInToken) (*dto.StoredRefreshToken, error) {
stored, err := a.refreshTokensRepo.GetByIDForUpdateTx(ctx, tx, data.TokenID)
if err != nil {
if apperr.CodeFromError(err) == apperr.CodeNotFound {
return nil, apperr.New(apperr.CodeUnauthorized, "invalid refresh token")
}
return nil, err
}
// Recheck expiry after acquiring the row lock: a concurrent rotation may have held it.
if err = a.validateStoredSession(ctx, dto.Token(token), data, stored); err != nil {
return nil, err
}
return stored, nil
}
func (a *Auth) validateStoredSession(ctx context.Context, token dto.Token, data *dto.UserDataInToken, stored *dto.StoredRefreshToken) error {
now := time.Now()
if stored.RevokedAt != nil || !stored.ExpiresAt.After(now) || !data.ExpiresAt.After(now) ||
stored.UserID != data.UserID || stored.Role != data.Role {
return apperr.New(apperr.CodeUnauthorized, "invalid session")
}
if err := a.encryptor.CompareHashAndSecretUsingSum256(ctx, stored.TokenHash, token.Payload); err != nil {
return apperr.New(apperr.CodeUnauthorized, "invalid session")
}
return nil
}
func (a *Auth) createTokensTx(ctx context.Context, tx pgx.Tx, userID uuid.UUID, previous *dto.StoredRefreshToken) (*dto.Tokens, error) {
tokens, err := a.jwt.CreateRefreshAndAccessTokensForUser(userID, role.User)
if err != nil {
return nil, apperr.Wrap(err, apperr.CodeInternal, "failed to generate tokens")
}
data, err := a.verifyToken(tokens.RefreshToken.Token(), false)
if err != nil {
return nil, apperr.Wrap(err, apperr.CodeInternal, "failed to validate generated refresh token")
}
hash, err := a.encryptor.EncryptSecretUsingSum256(ctx, tokens.RefreshToken.Payload)
if err != nil {
return nil, apperr.Wrap(err, apperr.CodeInternal, "failed to hash refresh token")
}
stored := dto.StoredRefreshToken{
ID: data.TokenID,
UserID: data.UserID,
TokenHash: hash,
Role: data.Role,
ExpiresAt: data.ExpiresAt,
CreatedAt: data.IssuedAt,
}
if previous != nil {
stored.UserAgent = previous.UserAgent
stored.IPAddress = previous.IPAddress
}
if err = a.refreshTokensRepo.CreateTx(ctx, tx, stored); err != nil {
return nil, err
}
return tokens, nil
}
+15
View File
@@ -0,0 +1,15 @@
package chat
import (
"context"
"gitea.privcloud.tech/mtusi2026/internal/dto"
)
type API interface {
CreateChat(ctx context.Context, req dto.CreateChat) (*dto.Chat, error)
GetForMember(ctx context.Context, req dto.ChatMember) (*dto.Chat, error)
ListForMember(ctx context.Context, req dto.ChatFilters) (*dto.Page[dto.Chat], error)
CreateMessage(ctx context.Context, req dto.CreateMessage) (*dto.Message, error)
ListForChat(ctx context.Context, req dto.MessageFilters) (*dto.Page[dto.Message], error)
}
@@ -0,0 +1,27 @@
package chat
import (
"context"
"github.com/google/uuid"
"github.com/jackc/pgx/v5"
"gitea.privcloud.tech/mtusi2026/internal/dto"
)
type chatsRepo interface {
CreateTx(ctx context.Context, tx pgx.Tx, req dto.Chat) error
GetForMember(ctx context.Context, req dto.ChatMember) (*dto.Chat, error)
ListForMember(ctx context.Context, userID uuid.UUID, page dto.PageQuery) ([]dto.Chat, error)
}
type messagesRepo interface {
Create(ctx context.Context, req dto.Message) error
GetByIDForChat(ctx context.Context, chatID, messageID uuid.UUID) (*dto.Message, error)
ListForChat(ctx context.Context, chatID uuid.UUID, page dto.PageQuery) ([]dto.Message, error)
}
type chatsCache interface {
Create(ctx context.Context, req dto.Chat) error
Get(ctx context.Context, chatID uuid.UUID) (*dto.Chat, error)
}
+242
View File
@@ -0,0 +1,242 @@
package chat
import (
"bytes"
"context"
"errors"
"log/slog"
"slices"
"time"
"github.com/google/uuid"
"github.com/jackc/pgx/v5"
"github.com/redis/go-redis/v9"
"golang.org/x/sync/singleflight"
"gitea.privcloud.tech/mtusi2026/internal/dto"
"gitea.privcloud.tech/mtusi2026/internal/pkg/apperr"
"gitea.privcloud.tech/mtusi2026/internal/pkg/postgres/txmanager"
)
var _ API = (*Chat)(nil)
const chatLoadTimeout = 2 * time.Second
type Chat struct {
tm *txmanager.TransactionManager
chatsRepo chatsRepo
messagesRepo messagesRepo
chatsCache chatsCache
loads singleflight.Group
}
func New(tm *txmanager.TransactionManager, chatsRepo chatsRepo, messagesRepo messagesRepo, chatsCache chatsCache) *Chat {
return &Chat{
tm: tm,
chatsRepo: chatsRepo,
messagesRepo: messagesRepo,
chatsCache: chatsCache,
}
}
func (c *Chat) CreateChat(ctx context.Context, req dto.CreateChat) (*dto.Chat, error) {
seen := make(map[uuid.UUID]struct{}, len(req.MemberIDs))
for _, id := range req.MemberIDs {
if id == uuid.Nil {
return nil, apperr.New(apperr.CodeBadRequest, "invalid chat member")
}
if _, exists := seen[id]; exists {
return nil, apperr.New(apperr.CodeBadRequest, "duplicate chat member")
}
seen[id] = struct{}{}
}
if _, included := seen[req.CreatorID]; !included {
return nil, apperr.New(apperr.CodeBadRequest, "creator must be a chat member")
}
members := slices.Clone(req.MemberIDs)
slices.SortFunc(members, func(a, b uuid.UUID) int {
return bytes.Compare(a[:], b[:])
})
chat := dto.Chat{
ID: uuid.New(),
Title: req.Title,
MemberIDs: members,
CreatedAt: time.Now().Truncate(time.Microsecond),
}
if err := c.tm.RunInTransaction(ctx, nil, func(tx pgx.Tx) error {
return c.chatsRepo.CreateTx(ctx, tx, chat)
}); err != nil {
return nil, err
}
return &chat, nil
}
func (c *Chat) GetForMember(ctx context.Context, req dto.ChatMember) (*dto.Chat, error) {
if err := ctx.Err(); err != nil {
return nil, err
}
if chat, err := c.cachedChat(ctx, req.ChatID); err == nil {
return chatForMember(chat, req.UserID)
}
// Repository results depend on membership: never share a user's 404 with
// another user requesting the same chat.
key := req.ChatID.String() + ":" + req.UserID.String()
result := c.loads.DoChan(key, func() (any, error) {
// One client disconnecting must not cancel the other clients' load.
loadCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), chatLoadTimeout)
defer cancel()
// A previous load may have populated Redis after our initial miss.
if chat, err := c.cachedChat(loadCtx, req.ChatID); err == nil {
return chatForMember(chat, req.UserID)
}
slog.Info("chat_db_lookup", "chat_id", req.ChatID)
chat, err := c.chatsRepo.GetForMember(loadCtx, req)
if err != nil {
return nil, err
}
if err = c.chatsCache.Create(loadCtx, *chat); err != nil {
slog.Warn("failed to cache chat", "chat_id", req.ChatID, "error", err)
}
return chat, nil
})
select {
case <-ctx.Done():
return nil, ctx.Err()
case loaded := <-result:
if err := ctx.Err(); err != nil {
return nil, err
}
if loaded.Err != nil {
return nil, loaded.Err
}
return chatForMember(loaded.Val.(*dto.Chat), req.UserID)
}
}
func (c *Chat) cachedChat(ctx context.Context, chatID uuid.UUID) (*dto.Chat, error) {
chat, err := c.chatsCache.Get(ctx, chatID)
switch {
case err == nil:
slog.Info("chat_cache_hit", "chat_id", chatID)
case errors.Is(err, redis.Nil):
slog.Info("chat_cache_miss", "chat_id", chatID)
default:
slog.Warn("chat_cache_read_error", "chat_id", chatID, "error", err)
}
return chat, err
}
func chatForMember(chat *dto.Chat, userID uuid.UUID) (*dto.Chat, error) {
if !slices.Contains(chat.MemberIDs, userID) {
return nil, apperr.New(apperr.CodeNotFound, "chat not found")
}
return chat, nil
}
func (c *Chat) ListForMember(ctx context.Context, req dto.ChatFilters) (*dto.Page[dto.Chat], error) {
limit, err := pageLimit(req.Limit)
if err != nil {
return nil, err
}
query := dto.PageQuery{Limit: limit + 1}
if req.AfterID != nil {
cursor, err := c.GetForMember(ctx, dto.ChatMember{UserID: req.UserID, ChatID: *req.AfterID})
if err != nil {
return nil, cursorError(err)
}
query.After = &dto.PagePosition{CreatedAt: cursor.CreatedAt, ID: cursor.ID}
}
items, err := c.chatsRepo.ListForMember(ctx, req.UserID, query)
if err != nil {
return nil, err
}
return makePage(items, limit, func(chat dto.Chat) uuid.UUID { return chat.ID }), nil
}
func (c *Chat) CreateMessage(ctx context.Context, req dto.CreateMessage) (*dto.Message, error) {
if _, err := c.GetForMember(ctx, dto.ChatMember{UserID: req.SenderID, ChatID: req.ChatID}); err != nil {
return nil, err
}
message := dto.Message{
ID: uuid.New(),
ChatID: req.ChatID,
SenderID: req.SenderID,
Text: req.Text,
CreatedAt: time.Now().Truncate(time.Microsecond),
}
if err := c.messagesRepo.Create(ctx, message); err != nil {
return nil, err
}
return &message, nil
}
func (c *Chat) ListForChat(ctx context.Context, req dto.MessageFilters) (*dto.Page[dto.Message], error) {
if _, err := c.GetForMember(ctx, dto.ChatMember{UserID: req.UserID, ChatID: req.ChatID}); err != nil {
return nil, err
}
limit, err := pageLimit(req.Limit)
if err != nil {
return nil, err
}
query := dto.PageQuery{Limit: limit + 1}
if req.AfterID != nil {
cursor, err := c.messagesRepo.GetByIDForChat(ctx, req.ChatID, *req.AfterID)
if err != nil {
return nil, cursorError(err)
}
query.After = &dto.PagePosition{CreatedAt: cursor.CreatedAt, ID: cursor.ID}
}
items, err := c.messagesRepo.ListForChat(ctx, req.ChatID, query)
if err != nil {
return nil, err
}
return makePage(items, limit, func(message dto.Message) uuid.UUID { return message.ID }), nil
}
func pageLimit(limit *int) (int, error) {
size := 50
if limit != nil {
size = *limit
}
if size < 1 || size > 100 {
return 0, apperr.New(apperr.CodeBadRequest, "invalid limit")
}
return size, nil
}
func cursorError(err error) error {
if apperr.CodeFromError(err) == apperr.CodeNotFound {
return apperr.New(apperr.CodeBadRequest, "invalid cursor")
}
return err
}
func makePage[T any](items []T, limit int, id func(T) uuid.UUID) *dto.Page[T] {
if items == nil {
items = make([]T, 0)
}
page := dto.Page[T]{Items: items}
if len(items) > limit {
page.Items = items[:limit]
cursor := id(page.Items[limit-1])
page.NextCursorID = &cursor
}
return &page
}
+15
View File
@@ -0,0 +1,15 @@
package user
import (
"context"
"github.com/google/uuid"
"gitea.privcloud.tech/mtusi2026/internal/dto"
)
type API interface {
Create(ctx context.Context, req dto.CreateUser) (*dto.User, error)
GetByID(ctx context.Context, id uuid.UUID) (*dto.User, error)
GetByUsername(ctx context.Context, username string) (*dto.User, error)
}
@@ -0,0 +1,15 @@
package user
import (
"context"
"github.com/google/uuid"
"gitea.privcloud.tech/mtusi2026/internal/dto"
)
type userRepo interface {
Create(ctx context.Context, req dto.CreateStoredUser) error
GetByID(ctx context.Context, id uuid.UUID) (*dto.User, error)
GetByUsername(ctx context.Context, username string) (*dto.User, error)
}
+67
View File
@@ -0,0 +1,67 @@
package user
import (
"context"
"time"
"github.com/google/uuid"
"gitea.privcloud.tech/mtusi2026/internal/dto"
"gitea.privcloud.tech/mtusi2026/internal/pkg/apperr"
"gitea.privcloud.tech/mtusi2026/internal/pkg/encrypting"
)
var (
_ API = (*User)(nil)
)
type User struct {
encryptor encrypting.Encryptor
usersRepo userRepo
}
func New(encryptor encrypting.Encryptor, usersRepo userRepo) *User {
return &User{encryptor: encryptor, usersRepo: usersRepo}
}
func (u *User) Create(ctx context.Context, req dto.CreateUser) (*dto.User, error) {
hash, err := u.encryptor.EncryptSecretUsingArgon2id(ctx, req.Password)
if err != nil {
return nil, apperr.Wrap(err, apperr.CodeInternal, "failed to hash password")
}
user := dto.User{
ID: uuid.New(),
Username: req.Username,
DisplayName: req.DisplayName,
CreatedAt: time.Now().Truncate(time.Microsecond),
}
if err = u.usersRepo.Create(ctx, dto.CreateStoredUser{
ID: user.ID,
Username: user.Username,
DisplayName: user.DisplayName,
PasswordHash: hash,
CreatedAt: user.CreatedAt,
UpdatedAt: user.CreatedAt,
}); err != nil {
return nil, err
}
return &user, nil
}
func (u *User) GetByID(ctx context.Context, id uuid.UUID) (*dto.User, error) {
user, err := u.usersRepo.GetByID(ctx, id)
if err != nil {
return nil, err
}
return user, nil
}
func (u *User) GetByUsername(ctx context.Context, username string) (*dto.User, error) {
user, err := u.usersRepo.GetByUsername(ctx, username)
if err != nil {
return nil, err
}
return user, nil
}
@@ -0,0 +1,18 @@
CREATE TABLE IF NOT EXISTS users
(
id UUID PRIMARY KEY,
name VARCHAR(100) NOT NULL,
username VARCHAR(32) NOT NULL,
password_hash TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
CONSTRAINT users_username_unique UNIQUE (username),
CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'),
CONSTRAINT users_name_not_blank CHECK (name !~ '^[[:space:]]*$'),
CONSTRAINT users_password_hash_not_empty CHECK (password_hash <> '')
);
---- create above / drop below ----
DROP TABLE IF EXISTS users;
@@ -0,0 +1,19 @@
CREATE TABLE IF NOT EXISTS refresh_tokens
(
id UUID PRIMARY KEY,
user_id UUID NOT NULL REFERENCES users (id),
token_hash TEXT NOT NULL,
user_agent TEXT,
ip_address INET,
role VARCHAR(16) NOT NULL,
expires_at TIMESTAMPTZ NOT NULL,
revoked_at TIMESTAMPTZ,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);
CREATE INDEX IF NOT EXISTS idx_refresh_user_id ON refresh_tokens (user_id);
CREATE INDEX IF NOT EXISTS idx_refresh_expires ON refresh_tokens (expires_at);
---- create above / drop below ----
DROP TABLE IF EXISTS refresh_tokens;
@@ -0,0 +1,14 @@
CREATE TABLE IF NOT EXISTS chats
(
id UUID PRIMARY KEY,
title VARCHAR(100) NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
CONSTRAINT chats_title_not_blank CHECK (title !~ '^[[:space:]]*$')
);
CREATE INDEX IF NOT EXISTS idx_chats_created_at_id ON chats (created_at, id);
---- create above / drop below ----
DROP TABLE IF EXISTS chats;
@@ -0,0 +1,15 @@
CREATE TABLE IF NOT EXISTS chat_members
(
chat_id UUID NOT NULL,
user_id UUID NOT NULL,
PRIMARY KEY (chat_id, user_id),
CONSTRAINT chat_members_chat_fk FOREIGN KEY (chat_id) REFERENCES chats (id) ON DELETE NO ACTION,
CONSTRAINT chat_members_user_fk FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE NO ACTION
);
CREATE INDEX IF NOT EXISTS idx_chat_members_user_id_chat_id ON chat_members (user_id, chat_id);
---- create above / drop below ----
DROP TABLE IF EXISTS chat_members;
@@ -0,0 +1,18 @@
CREATE TABLE IF NOT EXISTS messages
(
id UUID PRIMARY KEY,
chat_id UUID NOT NULL,
sender_id UUID NOT NULL,
text VARCHAR(4000) NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
CONSTRAINT messages_text_not_blank CHECK (text !~ '^[[:space:]]*$'),
CONSTRAINT messages_sender_member_fk FOREIGN KEY (chat_id, sender_id)
REFERENCES chat_members (chat_id, user_id) ON DELETE NO ACTION
);
CREATE INDEX IF NOT EXISTS idx_messages_chat_id_created_at_id ON messages (chat_id, created_at, id);
---- create above / drop below ----
DROP TABLE IF EXISTS messages;
+8
View File
@@ -0,0 +1,8 @@
package migrations
import (
"embed"
)
//go:embed *.sql
var Migrations embed.FS
+239
View File
@@ -0,0 +1,239 @@
package tests
import (
"encoding/json"
"fmt"
"net/http"
"net/http/httptest"
"net/url"
"strings"
"testing"
controller "gitea.privcloud.tech/mtusi2026/internal/adapter/controller/http"
inmemory2 "gitea.privcloud.tech/mtusi2026/internal/adapter/repository/cache/inmemory"
)
type apiClient struct {
handler http.Handler
}
type apiResponse struct {
status int
requestID string
body []byte
}
func newAPI(t *testing.T) *apiClient {
t.Helper()
router := controller.NewRouter()
users := inmemory2.NewUserCache()
chats := inmemory2.NewChatCache(users)
messages := inmemory2.NewMessageCache(chats)
base := controller.NewBaseHandler(router)
controller.NewAuthHandler(base, users).RegisterRoutes()
controller.NewChatHandler(base, users, chats, messages).RegisterRoutes()
return &apiClient{handler: router}
}
func (api *apiClient) request(t *testing.T, method, path, userID, body string) apiResponse {
t.Helper()
req := httptest.NewRequest(method, path, strings.NewReader(body))
if body != "" {
req.Header.Set("Content-Type", "application/json")
}
if userID != "" {
req.Header.Set("X-User-Id", userID)
}
recorder := httptest.NewRecorder()
api.handler.ServeHTTP(recorder, req)
resp := recorder.Result()
defer resp.Body.Close()
requestID := resp.Header.Get("X-Request-Id")
if requestID == "" {
t.Fatalf("%s %s: missing X-Request-Id", method, path)
}
return apiResponse{status: resp.StatusCode, requestID: requestID, body: recorder.Body.Bytes()}
}
func jsonString(t *testing.T, value any) string {
t.Helper()
data, err := json.Marshal(value)
if err != nil {
t.Fatalf("encode request: %v", err)
}
return string(data)
}
func decodeOK(t *testing.T, resp apiResponse, wantStatus int, target any) {
t.Helper()
if resp.status != wantStatus {
t.Fatalf("status = %d, want %d; body: %s", resp.status, wantStatus, resp.body)
}
if err := json.Unmarshal(resp.body, target); err != nil {
t.Fatalf("decode response %s: %v", resp.body, err)
}
}
func assertError(t *testing.T, resp apiResponse, wantStatus int, wantCode string) {
t.Helper()
if resp.status != wantStatus {
t.Fatalf("status = %d, want %d; body: %s", resp.status, wantStatus, resp.body)
}
var body struct {
Error struct {
Code string `json:"code"`
Message string `json:"message"`
RequestID string `json:"request_id"`
} `json:"error"`
}
if err := json.Unmarshal(resp.body, &body); err != nil {
t.Fatalf("decode error response %s: %v", resp.body, err)
}
if body.Error.Code != wantCode || body.Error.Message == "" || body.Error.RequestID != resp.requestID {
t.Fatalf("invalid error response: header request ID %q, body %s", resp.requestID, resp.body)
}
}
func (api *apiClient) createUser(t *testing.T, username string) string {
t.Helper()
resp := api.request(t, http.MethodPost, "/api/v1/users", "", jsonString(t, map[string]string{
"username": username, "display_name": username,
}))
var user struct {
ID string `json:"id"`
}
decodeOK(t, resp, http.StatusCreated, &user)
if user.ID == "" {
t.Fatal("created user has no ID")
}
return user.ID
}
func (api *apiClient) createChat(t *testing.T, creatorID string, memberIDs ...string) string {
t.Helper()
resp := api.request(t, http.MethodPost, "/api/v1/chats", creatorID, jsonString(t, map[string]any{
"title": "Test chat", "member_ids": memberIDs,
}))
var chat struct {
ID string `json:"id"`
}
decodeOK(t, resp, http.StatusCreated, &chat)
if chat.ID == "" {
t.Fatal("created chat has no ID")
}
return chat.ID
}
func TestInvalidJSON(t *testing.T) {
api := newAPI(t)
for _, tc := range []struct {
name string
body string
}{
{name: "malformed", body: `{"username":`},
{name: "wrong type", body: `{"username":42,"display_name":"Alice"}`},
{name: "unknown field", body: `{"username":"alice","display_name":"Alice","admin":true}`},
} {
t.Run(tc.name, func(t *testing.T) {
resp := api.request(t, http.MethodPost, "/api/v1/users", "", tc.body)
assertError(t, resp, http.StatusBadRequest, "invalid_request")
})
}
}
func TestForeignChatIsHidden(t *testing.T) {
api := newAPI(t)
alice := api.createUser(t, "alice")
bob := api.createUser(t, "bob")
eve := api.createUser(t, "eve")
chatID := api.createChat(t, alice, alice, bob)
for _, tc := range []struct {
method string
path string
body string
}{
{method: http.MethodGet, path: "/api/v1/chats/" + chatID},
{method: http.MethodGet, path: "/api/v1/chats/" + chatID + "/messages"},
{method: http.MethodPost, path: "/api/v1/chats/" + chatID + "/messages", body: `{"text":"secret"}`},
} {
resp := api.request(t, tc.method, tc.path, eve, tc.body)
assertError(t, resp, http.StatusNotFound, "not_found")
}
}
func TestEmptyMessage(t *testing.T) {
api := newAPI(t)
alice := api.createUser(t, "alice")
chatID := api.createChat(t, alice, alice)
path := "/api/v1/chats/" + chatID + "/messages"
for _, body := range []string{`{"text":""}`, `{"text":" \t\n "}`} {
resp := api.request(t, http.MethodPost, path, alice, body)
assertError(t, resp, http.StatusBadRequest, "invalid_request")
}
}
func TestDuplicateUsername(t *testing.T) {
api := newAPI(t)
api.createUser(t, "alice")
resp := api.request(t, http.MethodPost, "/api/v1/users", "", `{"username":"alice","display_name":"Another Alice"}`)
assertError(t, resp, http.StatusConflict, "conflict")
}
func TestMessagePagination(t *testing.T) {
api := newAPI(t)
alice := api.createUser(t, "alice")
chatID := api.createChat(t, alice, alice)
wantIDs := make(map[string]bool)
for i := range 5 {
resp := api.request(t, http.MethodPost, "/api/v1/chats/"+chatID+"/messages", alice,
jsonString(t, map[string]string{"text": fmt.Sprintf("message %d", i)}))
var message struct {
ID string `json:"id"`
}
decodeOK(t, resp, http.StatusCreated, &message)
if message.ID == "" || wantIDs[message.ID] {
t.Fatalf("invalid or duplicate created message ID %q", message.ID)
}
wantIDs[message.ID] = true
}
seen := make(map[string]bool)
cursor := ""
pages := 0
for {
path := "/api/v1/chats/" + chatID + "/messages?limit=2"
if cursor != "" {
path += "&cursor=" + url.QueryEscape(cursor)
}
resp := api.request(t, http.MethodGet, path, alice, "")
var page struct {
Items []struct {
ID string `json:"id"`
} `json:"items"`
NextCursor *string `json:"next_cursor"`
}
decodeOK(t, resp, http.StatusOK, &page)
pages++
if pages > 3 || len(page.Items) == 0 || len(page.Items) > 2 {
t.Fatalf("unexpected page %d: %s", pages, resp.body)
}
for _, message := range page.Items {
if !wantIDs[message.ID] || seen[message.ID] {
t.Fatalf("unexpected or repeated message ID %q on page %d", message.ID, pages)
}
seen[message.ID] = true
}
if page.NextCursor == nil {
break
}
if *page.NextCursor == "" || *page.NextCursor == cursor {
t.Fatalf("invalid next cursor on page %d: %s", pages, resp.body)
}
cursor = *page.NextCursor
}
if pages != 3 || len(seen) != len(wantIDs) {
t.Fatalf("got %d pages and %d unique messages, want 3 pages and %d messages", pages, len(seen), len(wantIDs))
}
}
+162
View File
@@ -0,0 +1,162 @@
package tests
import (
"encoding/json"
"fmt"
"io"
"net/http"
"net/http/httptest"
"net/url"
"strings"
"sync"
"testing"
"time"
)
type createdMessage struct {
ID string `json:"id"`
SenderID string `json:"sender_id"`
Text string `json:"text"`
}
func postMessage(client *http.Client, endpoint, userID, text string) (createdMessage, error) {
body, err := json.Marshal(struct {
Text string `json:"text"`
}{Text: text})
if err != nil {
return createdMessage{}, err
}
req, err := http.NewRequest(http.MethodPost, endpoint, strings.NewReader(string(body)))
if err != nil {
return createdMessage{}, err
}
req.Header.Set("Content-Type", "application/json")
req.Header.Set("X-User-Id", userID)
resp, err := client.Do(req)
if err != nil {
return createdMessage{}, err
}
defer resp.Body.Close()
data, err := io.ReadAll(resp.Body)
if err != nil {
return createdMessage{}, err
}
if resp.StatusCode != http.StatusCreated {
return createdMessage{}, fmt.Errorf("POST status %d: %s", resp.StatusCode, data)
}
if resp.Header.Get("X-Request-Id") == "" {
return createdMessage{}, fmt.Errorf("POST response has no X-Request-Id")
}
var message createdMessage
if err := json.Unmarshal(data, &message); err != nil {
return createdMessage{}, fmt.Errorf("decode POST response: %w", err)
}
return message, nil
}
func TestConcurrentMessages(t *testing.T) {
const clients = 10
const messagesPerClient = 10
const total = clients * messagesPerClient
api := newAPI(t)
users := make([]string, clients)
for i := range users {
users[i] = api.createUser(t, fmt.Sprintf("user%02d", i))
}
chatID := api.createChat(t, users[0], users...)
server := httptest.NewServer(api.handler)
t.Cleanup(server.Close)
endpoint := server.URL + "/api/v1/chats/" + chatID + "/messages"
type result struct {
message createdMessage
wantSenderID string
wantText string
err error
}
results := make(chan result, total)
start := make(chan struct{})
var ready sync.WaitGroup
var workers sync.WaitGroup
ready.Add(clients)
workers.Add(clients)
for i, userID := range users {
go func(workerID int, userID string) {
defer workers.Done()
client := &http.Client{Timeout: 5 * time.Second}
defer client.CloseIdleConnections()
ready.Done()
<-start
for j := range messagesPerClient {
text := fmt.Sprintf("client-%02d-message-%02d", workerID, j)
message, err := postMessage(client, endpoint, userID, text)
results <- result{message: message, wantSenderID: userID, wantText: text, err: err}
}
}(i, userID)
}
ready.Wait()
close(start)
workers.Wait()
close(results)
created := make(map[string]createdMessage, total)
count := 0
for item := range results {
count++
if item.err != nil {
t.Errorf("send %q: %v", item.wantText, item.err)
continue
}
if item.message.ID == "" || item.message.SenderID != item.wantSenderID || item.message.Text != item.wantText {
t.Errorf("unexpected response for %q: %+v", item.wantText, item.message)
continue
}
if _, duplicate := created[item.message.ID]; duplicate {
t.Errorf("duplicate message ID %q", item.message.ID)
continue
}
created[item.message.ID] = item.message
}
if count != total || len(created) != total {
t.Fatalf("sent %d requests, created %d unique messages; want %d", count, len(created), total)
}
seen := make(map[string]bool, total)
cursor := ""
pages := 0
for {
path := "/api/v1/chats/" + chatID + "/messages?limit=17"
if cursor != "" {
path += "&cursor=" + url.QueryEscape(cursor)
}
resp := api.request(t, http.MethodGet, path, users[0], "")
var page struct {
Items []createdMessage `json:"items"`
NextCursor *string `json:"next_cursor"`
}
decodeOK(t, resp, http.StatusOK, &page)
pages++
if pages > total || len(page.Items) == 0 || len(page.Items) > 17 {
t.Fatalf("unexpected page %d: %s", pages, resp.body)
}
for _, message := range page.Items {
want, exists := created[message.ID]
if !exists || seen[message.ID] || message != want {
t.Fatalf("unexpected or repeated message on page %d: %+v", pages, message)
}
seen[message.ID] = true
}
if page.NextCursor == nil {
break
}
if *page.NextCursor == "" || *page.NextCursor == cursor {
t.Fatalf("invalid cursor on page %d: %s", pages, resp.body)
}
cursor = *page.NextCursor
}
if len(seen) != total {
t.Fatalf("history has %d unique messages across %d pages; want %d", len(seen), pages, total)
}
t.Logf("%d clients sent %d messages; history contains %d unique messages across %d pages", clients, total, len(seen), pages)
}