forked from mtusi2026/mtusi2026lab3
Перенес необходимые изменения из лабораторной работы №2
This commit is contained in:
+56
-6
@@ -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
@@ -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"]
|
||||
@@ -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
|
||||
|
||||
|
||||
@@ -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:
|
||||
@@ -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()
|
||||
}
|
||||
}
|
||||
@@ -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))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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
@@ -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
|
||||
}
|
||||
@@ -0,0 +1,7 @@
|
||||
package config
|
||||
|
||||
import "github.com/spf13/viper"
|
||||
|
||||
type Loader interface {
|
||||
loadConfig(v *viper.Viper) error
|
||||
}
|
||||
@@ -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,
|
||||
}
|
||||
}
|
||||
@@ -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(),
|
||||
}
|
||||
}
|
||||
@@ -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,
|
||||
}
|
||||
}
|
||||
@@ -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,
|
||||
}
|
||||
}
|
||||
@@ -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,
|
||||
}
|
||||
}
|
||||
@@ -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,
|
||||
}
|
||||
}
|
||||
@@ -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,
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
@@ -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]]
|
||||
}
|
||||
@@ -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()
|
||||
}
|
||||
@@ -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()
|
||||
}
|
||||
@@ -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"
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
Vendored
+43
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,7 @@
|
||||
package postgres
|
||||
|
||||
type MigrationConfig interface {
|
||||
GetURI() string
|
||||
GetVersionTableName() string
|
||||
GetRunMigrations() bool
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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))
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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")
|
||||
)
|
||||
@@ -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)
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
@@ -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;
|
||||
@@ -0,0 +1,8 @@
|
||||
package migrations
|
||||
|
||||
import (
|
||||
"embed"
|
||||
)
|
||||
|
||||
//go:embed *.sql
|
||||
var Migrations embed.FS
|
||||
@@ -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))
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
Reference in New Issue
Block a user