Prepare verified laboratory 2 implementation and evidence

This commit is contained in:
rey
2026-11-17 17:31:17 +03:00
parent 65003b6119
commit 62d7c2023c
85 changed files with 9426 additions and 38 deletions
+36
View File
@@ -0,0 +1,36 @@
version: "2"
run:
allow-parallel-runners: true
linters:
default: standard
enable: [depguard]
settings:
errcheck:
# Close тела ответа и файла, открытого на чтение: ошибке некуда деться.
exclude-functions:
- (io.ReadCloser).Close
- (*os.File).Close
depguard:
rules:
# Гексагон: ядро и use-case'ы зависят от портов, а не от адаптеров и транспорта.
inner-pure:
files: ["**/internal/domain/**", "**/internal/application/**"]
deny:
- pkg: backend/internal/adapter
desc: домен и приложение зависят от портов, не от адаптеров
- pkg: backend/internal/config
desc: конфиг читает только cmd
- pkg: net/http
desc: HTTP только в adapter/handler
- pkg: github.com/go-chi
desc: роутер только в adapter/handler
- pkg: github.com/rs/zerolog
desc: логирование на границе, в адаптерах
domain-core:
files: ["**/internal/domain/**"]
deny:
- pkg: backend/internal/application
desc: домен не знает о use-case'ах
exclusions:
paths:
- ".*\\.gen\\.go$"
+133
View File
@@ -0,0 +1,133 @@
package main
import (
"context"
"errors"
"flag"
"fmt"
"net/http"
"os"
"os/signal"
"syscall"
"time"
"backend/db"
"backend/internal/adapter/handler"
"backend/internal/adapter/password"
"backend/internal/adapter/repository/postgres"
"backend/internal/application/usecase"
"backend/internal/config"
"backend/pkg/logger"
"backend/pkg/server"
"github.com/jackc/pgx/v5/pgxpool"
"github.com/redis/go-redis/v9"
)
func main() {
healthcheck := flag.Bool("healthcheck", false, "проверить /health/ready и выйти (для Docker HEALTHCHECK)")
migrate := flag.Bool("migrate", false, "apply migrations and exit")
flag.Parse()
cfg, err := config.Load()
if err != nil {
fmt.Fprintln(os.Stderr, "config:", err)
os.Exit(1)
}
if *healthcheck {
os.Exit(probe(cfg.Port))
}
log := logger.New(cfg.LogLevel)
dsn, err := config.ReadSecret(cfg.DatabaseURLFile)
if err != nil {
log.Fatal().Msg("database secret unavailable")
}
if *migrate {
if err = db.Migrate(context.Background(), dsn); err != nil {
log.Fatal().Err(err).Msg("migration failed")
}
return
}
pc, err := pgxpool.ParseConfig(dsn)
if err != nil {
log.Fatal().Msg("invalid database configuration")
}
pc.MaxConns = cfg.MaxConns
pc.MinConns = 0
pc.ConnConfig.ConnectTimeout = time.Second
pc.ConnConfig.RuntimeParams["statement_timeout"] = "2000"
pc.ConnConfig.RuntimeParams["lock_timeout"] = "1000"
pool, err := pgxpool.NewWithConfig(context.Background(), pc)
if err != nil {
log.Fatal().Msg("database initialization failed")
}
defer pool.Close()
var cache *redis.Client
if url, e := config.ReadSecret(cfg.CacheURLFile); e == nil {
opts, e := redis.ParseURL(url)
if e != nil {
log.Fatal().Msg("invalid cache configuration")
}
opts.MaxRetries = 0
opts.DialTimeout = 80 * time.Millisecond
opts.ReadTimeout = 80 * time.Millisecond
opts.WriteTimeout = 80 * time.Millisecond
cache = redis.NewClient(opts)
defer func(){_ = cache.Close()}()
}
store := postgres.New(pool, cache)
app := usecase.NewMessenger(store)
auth := usecase.NewAuth(store, password.New(), app, time.Duration(cfg.SessionTTLSeconds)*time.Second, time.Now)
h := handler.New(app, auth, pool.Ping, handler.Limits{
MaxBodyBytes: cfg.MaxBodyBytes,
MaxInflight: cfg.MaxInflight,
MaxQueue: cfg.MaxQueue,
QueueTimeout: cfg.QueueTimeout,
}, func() any {
return map[string]any{"pool_total": pool.Stat().TotalConns(), "pool_acquired": pool.Stat().AcquiredConns(),"pool_max":pool.Stat().MaxConns()}
}, &log)
srv := server.New(cfg.Addr(), h.Router())
ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGTERM, syscall.SIGINT)
defer stop()
serveErr := make(chan error, 1)
go func() { serveErr <- srv.ListenAndServe() }()
log.Info().Str("addr", cfg.Addr()).Str("env", cfg.Env).
Int("max_inflight", cfg.MaxInflight).
Int("max_queue", cfg.MaxQueue).Msg("server started")
select {
case err := <-serveErr:
log.Fatal().Err(err).Msg("server failed")
case <-ctx.Done():
}
started := time.Now()
log.Info().Dur("timeout", cfg.ShutdownTimeout).Msg("shutdown signal received, draining")
h.Drain()
shutdownCtx, cancel := context.WithTimeout(context.Background(), cfg.ShutdownTimeout)
defer cancel()
if err := srv.Shutdown(shutdownCtx); err != nil {
log.Error().Err(err).Msg("shutdown timed out, open requests aborted")
}
if err := <-serveErr; err != nil && !errors.Is(err, http.ErrServerClosed) {
log.Error().Err(err).Msg("server error")
}
log.Info().Dur("took", time.Since(started)).Msg("shutdown complete")
}
// probe — healthcheck без curl в образе distroless: сам бинарник ходит в
// /health/ready и возвращает код выхода для Docker.
func probe(port int) int {
client := http.Client{Timeout: 2 * time.Second}
resp, err := client.Get(fmt.Sprintf("http://127.0.0.1:%d/health/ready", port))
if err != nil {
return 1
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
return 1
}
return 0
}
+13
View File
@@ -0,0 +1,13 @@
package: handler
generate:
models: true
chi-server: true
strict-server: true
output: api.gen.go
output-options:
# date-time -> handler.Timestamp: ровно 6 цифр дробной части (см. timestamp.go)
type-mapping:
string:
formats:
date-time:
type: Timestamp
+25
View File
@@ -0,0 +1,25 @@
package db
import (
"context"
"database/sql"
"embed"
_ "github.com/jackc/pgx/v5/stdlib"
"github.com/pressly/goose/v3"
)
//go:embed migrations/*.sql
var migrations embed.FS
func Migrate(ctx context.Context, dsn string) error {
conn, err := sql.Open("pgx", dsn)
if err != nil {
return err
}
defer func(){_ = conn.Close()}()
goose.SetBaseFS(migrations)
if err = goose.SetDialect("postgres"); err != nil {
return err
}
return goose.UpContext(ctx, conn, "migrations")
}
+44
View File
@@ -0,0 +1,44 @@
-- +goose Up
CREATE TABLE users (
id uuid PRIMARY KEY,
username text NOT NULL UNIQUE CHECK (username ~ '^[a-z0-9_]{3,32}$'),
display_name text NOT NULL CHECK (char_length(display_name) BETWEEN 1 AND 100),
password_hash text NOT NULL,
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
chat_count integer NOT NULL DEFAULT 0 CHECK (chat_count BETWEEN 0 AND 1000),
message_count integer NOT NULL DEFAULT 0 CHECK (message_count BETWEEN 0 AND 1000000)
);
CREATE TABLE chats (
id uuid PRIMARY KEY,
title text NOT NULL CHECK (char_length(title) BETWEEN 1 AND 100),
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
);
CREATE TABLE chat_members (
chat_id uuid NOT NULL REFERENCES chats(id),
user_id uuid NOT NULL REFERENCES users(id),
PRIMARY KEY (chat_id, user_id)
);
CREATE INDEX member_chats ON chat_members(user_id,chat_id);
CREATE INDEX chats_order ON chats(created_at,id);
CREATE TABLE messages (
id uuid PRIMARY KEY,
chat_id uuid NOT NULL REFERENCES chats(id),
sender_id uuid NOT NULL REFERENCES users(id),
text text NOT NULL CHECK (char_length(text) BETWEEN 1 AND 4000),
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
FOREIGN KEY (chat_id,sender_id) REFERENCES chat_members(chat_id,user_id)
);
CREATE INDEX messages_history ON messages(chat_id,created_at,id);
CREATE TABLE sessions (
token_hash text PRIMARY KEY CHECK (length(token_hash)=64),
user_id uuid NOT NULL REFERENCES users(id),
expires_at timestamptz NOT NULL
);
CREATE INDEX sessions_user ON sessions(user_id,expires_at);
-- +goose Down
DROP TABLE sessions;
DROP TABLE messages;
DROP TABLE chat_members;
DROP TABLE chats;
DROP TABLE users;
+41
View File
@@ -0,0 +1,41 @@
-- name: CreateUser :one
INSERT INTO users(id,username,display_name,password_hash) VALUES($1,$2,$3,$4)
RETURNING id,username,display_name,created_at;
-- name: GetUser :one
SELECT id,username,display_name,created_at FROM users WHERE id=$1;
-- name: Credentials :one
SELECT id,password_hash FROM users WHERE username=$1;
-- name: ChargeChat :one
UPDATE users SET chat_count=chat_count+1 WHERE id=$1 AND chat_count<1000 RETURNING id;
-- name: ChargeMessage :one
UPDATE users SET message_count=message_count+1 WHERE id=$1 AND message_count<1000000 RETURNING id;
-- name: InsertChat :one
INSERT INTO chats(id,title) VALUES($1,$2) RETURNING id,title,created_at;
-- name: InsertMembers :exec
INSERT INTO chat_members(chat_id,user_id) SELECT $1,unnest($2::uuid[]);
-- name: GetChat :one
SELECT c.id,c.title,c.created_at,ARRAY(SELECT user_id FROM chat_members WHERE chat_id=c.id ORDER BY user_id)::uuid[] AS members
FROM chats c WHERE c.id=$1;
-- name: ListChats :many
SELECT c.id,c.title,c.created_at,ARRAY(SELECT user_id FROM chat_members WHERE chat_id=c.id ORDER BY user_id)::uuid[] AS members
FROM chats c JOIN chat_members m ON m.chat_id=c.id
WHERE m.user_id=sqlc.arg(member_id) AND (c.created_at,c.id)>(sqlc.arg(after_time)::timestamptz,sqlc.arg(after_id)::uuid)
ORDER BY c.created_at,c.id LIMIT sqlc.arg(page_limit);
-- name: InsertMessage :one
INSERT INTO messages(id,chat_id,sender_id,text) VALUES($1,$2,$3,$4) RETURNING id,chat_id,sender_id,text,created_at;
-- name: ListMessages :many
SELECT id,chat_id,sender_id,text,created_at FROM messages
WHERE chat_id=$1 AND (created_at,id)>(sqlc.arg(after_time)::timestamptz,sqlc.arg(after_id)::uuid)
ORDER BY created_at,id LIMIT sqlc.arg(page_limit);
-- name: LockSessionOwner :one
SELECT id FROM users WHERE id=$1 FOR UPDATE;
-- name: DeleteExpiredSessions :exec
DELETE FROM sessions WHERE user_id=$1 AND expires_at<=clock_timestamp();
-- name: InsertSession :one
INSERT INTO sessions(token_hash,user_id,expires_at)
SELECT $1,$2,$3 WHERE (SELECT count(*) FROM sessions WHERE user_id=$2)<100
RETURNING user_id;
-- name: AuthenticateSession :one
SELECT user_id FROM sessions WHERE token_hash=$1 AND expires_at>clock_timestamp();
-- name: RevokeSession :exec
DELETE FROM sessions WHERE token_hash=$1;
+16
View File
@@ -0,0 +1,16 @@
version: '2'
sql:
- schema: ../migrations
queries: queries
engine: postgresql
gen:
go:
package: queries
out: ../../internal/adapter/repository/postgres/queries
sql_package: pgx/v5
emit_empty_slices: true
overrides:
- db_type: uuid
go_type: github.com/google/uuid.UUID
- db_type: timestamptz
go_type: time.Time
+321
View File
@@ -0,0 +1,321 @@
module backend
go 1.27.2
tool (
github.com/golangci/golangci-lint/v2/cmd/golangci-lint
github.com/oapi-codegen/oapi-codegen/v2/cmd/oapi-codegen
github.com/pressly/goose/v3/cmd/goose
github.com/sqlc-dev/sqlc/cmd/sqlc
)
require (
github.com/go-chi/chi/v5 v5.5.0
github.com/google/uuid v1.6.0
github.com/oapi-codegen/runtime v1.7.0
github.com/rs/zerolog v1.35.1
github.com/spf13/viper v1.21.0
)
require (
4d63.com/gocheckcompilerdirectives v1.4.0 // indirect
4d63.com/gochecknoglobals v0.2.2 // indirect
cel.dev/expr v0.25.3 // indirect
charm.land/lipgloss/v2 v2.0.6 // indirect
codeberg.org/chavacava/garif v0.2.1 // indirect
codeberg.org/polyfloyd/go-errorlint v1.9.0 // indirect
dev.gaijin.team/go/exhaustruct/v4 v4.0.0 // indirect
dev.gaijin.team/go/exhaustruct/v5 v5.2.0 // indirect
dev.gaijin.team/go/golib v0.8.1 // indirect
filippo.io/edwards25519 v1.2.0 // indirect
github.com/4meepo/tagalign v1.4.4 // indirect
github.com/Abirdcfly/dupword v0.1.8 // indirect
github.com/AdminBenni/iota-mixing v1.0.0 // indirect
github.com/AlwxSin/noinlineerr v1.0.6 // indirect
github.com/Antonboom/errname v1.1.2 // indirect
github.com/Antonboom/nilnil v1.1.2 // indirect
github.com/Antonboom/testifylint v1.6.4 // indirect
github.com/Azure/azure-sdk-for-go/sdk/azcore v1.24.0 // indirect
github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.15.0 // indirect
github.com/Azure/azure-sdk-for-go/sdk/internal v1.13.0 // indirect
github.com/AzureAD/microsoft-authentication-library-for-go v1.10.1 // indirect
github.com/BurntSushi/toml v1.6.0 // indirect
github.com/ClickHouse/ch-go v0.75.0 // indirect
github.com/ClickHouse/clickhouse-go-linter v1.2.1 // indirect
github.com/ClickHouse/clickhouse-go/v2 v2.51.0 // indirect
github.com/Djarvur/go-err113 v0.1.1 // indirect
github.com/Masterminds/semver/v3 v3.5.0 // indirect
github.com/MirrexOne/unqueryvet v1.5.4 // indirect
github.com/OpenPeeDeeP/depguard/v2 v2.2.1 // indirect
github.com/alecthomas/chroma/v2 v2.27.0 // indirect
github.com/alecthomas/go-check-sumtype v0.5.1-0.20260828200218-ae6904d28606 // indirect
github.com/alexkohler/nakedret/v2 v2.0.6 // indirect
github.com/alexkohler/prealloc v1.1.0 // indirect
github.com/alfatraining/structtag v1.0.0 // indirect
github.com/alingse/asasalint v0.0.11 // indirect
github.com/alingse/nilnesserr v0.2.0 // indirect
github.com/andybalholm/brotli v1.3.0 // indirect
github.com/antlr4-go/antlr/v4 v4.13.1 // indirect
github.com/apapsch/go-jsonmerge/v2 v2.0.0 // indirect
github.com/ashanbrown/forbidigo/v2 v2.3.1 // indirect
github.com/ashanbrown/makezero/v2 v2.2.1 // indirect
github.com/beorn7/perks v1.0.1 // indirect
github.com/bkielbasa/cyclop v1.2.3 // indirect
github.com/blizzy78/varnamelen v0.8.0 // indirect
github.com/bombsimon/wsl/v4 v4.7.0 // indirect
github.com/bombsimon/wsl/v5 v5.9.0 // indirect
github.com/breml/bidichk v0.3.3 // indirect
github.com/breml/errchkjson v0.4.1 // indirect
github.com/butuzov/ireturn v0.4.1 // indirect
github.com/butuzov/mirror v1.3.3 // indirect
github.com/catenacyber/perfsprint v0.10.1 // indirect
github.com/ccojocar/zxcvbn-go v1.0.4 // indirect
github.com/cespare/xxhash/v2 v2.3.0 // indirect
github.com/charithe/durationcheck v0.0.11 // indirect
github.com/charmbracelet/colorprofile v0.4.3 // indirect
github.com/charmbracelet/ultraviolet v0.0.0-20260811164956-006e29f97886 // indirect
github.com/charmbracelet/x/ansi v0.11.8 // indirect
github.com/charmbracelet/x/term v0.2.2 // indirect
github.com/charmbracelet/x/termios v0.1.1 // indirect
github.com/charmbracelet/x/windows v0.2.2 // indirect
github.com/ckaznocha/intrange v0.3.1 // indirect
github.com/clipperhouse/displaywidth v0.11.0 // indirect
github.com/clipperhouse/uax29/v2 v2.7.0 // indirect
github.com/coder/websocket v1.8.15 // indirect
github.com/coreos/go-semver v0.3.1 // indirect
github.com/cubicdaiya/gonp v1.0.4 // indirect
github.com/curioswitch/go-reassign v0.3.0 // indirect
github.com/daixiang0/gci v0.13.7 // indirect
github.com/dave/dst v0.27.3 // indirect
github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
github.com/denis-tingaikin/go-header v0.5.0 // indirect
github.com/dlclark/regexp2/v2 v2.2.1 // indirect
github.com/dprotaso/go-yit v0.0.0-20220510233725-9ba8df137936 // indirect
github.com/dustin/go-humanize v1.1.0 // indirect
github.com/elastic/go-sysinfo v1.15.5 // indirect
github.com/elastic/go-windows v1.0.2 // indirect
github.com/ettle/strcase v0.2.0 // indirect
github.com/fatih/color v1.19.0 // indirect
github.com/fatih/structtag v1.2.0 // indirect
github.com/firefart/nonamedreturns v1.0.8 // indirect
github.com/fsnotify/fsnotify v1.9.0 // indirect
github.com/fzipp/gocyclo v0.6.0 // indirect
github.com/getkin/kin-openapi v0.142.0 // indirect
github.com/ghostiam/protogetter v1.0.1 // indirect
github.com/go-critic/go-critic v0.15.0 // indirect
github.com/go-faster/city v1.0.1 // indirect
github.com/go-faster/errors v0.8.0 // indirect
github.com/go-openapi/jsonpointer v0.23.1 // indirect
github.com/go-openapi/swag/jsonname v0.26.0 // indirect
github.com/go-sql-driver/mysql v1.10.1 // indirect
github.com/go-toolsmith/astcast v1.1.0 // indirect
github.com/go-toolsmith/astcopy v1.1.0 // indirect
github.com/go-toolsmith/astequal v1.2.0 // indirect
github.com/go-toolsmith/astfmt v1.1.0 // indirect
github.com/go-toolsmith/astp v1.1.0 // indirect
github.com/go-toolsmith/strparse v1.1.0 // indirect
github.com/go-toolsmith/typep v1.1.0 // indirect
github.com/go-viper/mapstructure/v2 v2.5.0 // indirect
github.com/go-xmlfmt/xmlfmt v1.1.3 // indirect
github.com/gobwas/glob v0.2.3 // indirect
github.com/godoc-lint/godoc-lint v0.11.4 // indirect
github.com/gofrs/flock v0.13.1 // indirect
github.com/golang-jwt/jwt/v4 v4.5.2 // indirect
github.com/golang-jwt/jwt/v5 v5.3.1 // indirect
github.com/golang-sql/civil v0.0.0-20220223132316-b832511892a9 // indirect
github.com/golang-sql/sqlexp v0.1.0 // indirect
github.com/golang/protobuf v1.5.4 // indirect
github.com/golangci/asciicheck v0.5.0 // indirect
github.com/golangci/canonicalheader v0.0.0-20260827115959-a25c71c521f6 // indirect
github.com/golangci/dupl v0.0.0-20260401084720-c99c5cf5c202 // indirect
github.com/golangci/go-printf-func-name v0.1.1 // indirect
github.com/golangci/gofmt v0.0.0-20260820135601-e84e05053792 // indirect
github.com/golangci/golangci-lint/v2 v2.14.0 // indirect
github.com/golangci/golines v0.15.0 // indirect
github.com/golangci/misspell v0.8.0 // indirect
github.com/golangci/plugin-module-register v0.1.2 // indirect
github.com/golangci/revgrep v0.8.0 // indirect
github.com/golangci/rowserrcheck v0.0.0-20260419091836-c5f79b8a11ba // indirect
github.com/golangci/swaggoswag v0.0.0-20250504205917-77f2aca3143e // indirect
github.com/golangci/unconvert v0.0.0-20250410112200-a129a6e6413e // indirect
github.com/google/cel-go v0.28.0 // indirect
github.com/google/go-cmp v0.7.0 // indirect
github.com/gordonklaus/ineffassign v0.2.0 // indirect
github.com/gostaticanalysis/analysisutil v0.7.1 // indirect
github.com/gostaticanalysis/comment v1.5.0 // indirect
github.com/gostaticanalysis/forcetypeassert v0.2.0 // indirect
github.com/gostaticanalysis/nilerr v0.1.2 // indirect
github.com/hashicorp/go-immutable-radix/v2 v2.1.0 // indirect
github.com/hashicorp/go-version v1.9.0 // indirect
github.com/hashicorp/golang-lru/v2 v2.0.7 // indirect
github.com/hexops/gotextdiff v1.0.3 // indirect
github.com/inconshreveable/mousetrap v1.1.0 // indirect
github.com/jackc/pgpassfile v1.0.0 // indirect
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
github.com/jackc/pgx/v5 v5.13.0 // indirect
github.com/jackc/puddle/v2 v2.2.3 // indirect
github.com/jgautheron/goconst v1.11.0 // indirect
github.com/jinzhu/inflection v1.0.0 // indirect
github.com/jjti/go-spancheck v0.6.5 // indirect
github.com/joho/godotenv v1.5.1 // indirect
github.com/jonboulle/clockwork v0.5.0 // indirect
github.com/julz/importas v0.2.0 // indirect
github.com/karamaru-alpha/copyloopvar v1.2.2 // indirect
github.com/kisielk/errcheck v1.20.0 // indirect
github.com/kkHAIKE/contextcheck v1.1.6 // indirect
github.com/klauspost/compress v1.20.4 // indirect
github.com/kulti/thelper v0.7.1 // indirect
github.com/kunwardeep/paralleltest v1.0.15 // indirect
github.com/kylelemons/godebug v1.1.0 // indirect
github.com/ldez/exptostd v0.4.5 // indirect
github.com/ldez/gomoddirectives v0.10.0 // indirect
github.com/ldez/grignotin v0.10.1 // indirect
github.com/ldez/structtags v0.6.1 // indirect
github.com/ldez/tagliatelle v0.8.0 // indirect
github.com/ldez/usetesting v0.5.0 // indirect
github.com/leonklingele/grouper v1.1.2 // indirect
github.com/lucasb-eyer/go-colorful v1.4.1 // indirect
github.com/macabu/inamedparam v0.2.0 // indirect
github.com/manuelarte/embeddedstructfieldcheck v0.4.0 // indirect
github.com/manuelarte/funcorder v0.6.0 // indirect
github.com/maratori/testableexamples v1.0.1 // indirect
github.com/maratori/testpackage v1.1.2 // indirect
github.com/matoous/godox v1.1.0 // indirect
github.com/mattn/go-colorable v0.1.15 // indirect
github.com/mattn/go-isatty v0.0.24 // indirect
github.com/mattn/go-runewidth v0.0.24 // indirect
github.com/matttproud/golang_protobuf_extensions v1.0.1 // indirect
github.com/mfridman/interpolate v0.0.2 // indirect
github.com/mfridman/xflag v0.1.0 // indirect
github.com/mgechev/revive v1.17.0 // indirect
github.com/microsoft/go-mssqldb v1.11.2 // indirect
github.com/mitchellh/go-homedir v1.1.0 // indirect
github.com/moricho/tparallel v0.3.2 // indirect
github.com/muesli/cancelreader v0.2.2 // indirect
github.com/nakabonne/nestif v0.3.1 // indirect
github.com/ncruces/go-sqlite3 v0.32.0 // indirect
github.com/ncruces/go-strftime v1.1.0 // indirect
github.com/ncruces/julianday v1.0.0 // indirect
github.com/nishanths/exhaustive v0.13.0 // indirect
github.com/nishanths/predeclared v0.2.2 // indirect
github.com/nunnatsa/ginkgolinter v0.24.0 // indirect
github.com/oapi-codegen/oapi-codegen/v2 v2.8.0 // indirect
github.com/oasdiff/yaml v0.1.1 // indirect
github.com/oasdiff/yaml3 v0.0.14 // indirect
github.com/paulmach/orb v0.14.0 // indirect
github.com/pelletier/go-toml/v2 v2.4.3 // indirect
github.com/pganalyze/pg_query_go/v6 v6.2.2 // indirect
github.com/pierrec/lz4/v4 v4.1.33 // indirect
github.com/pingcap/errors v0.11.5-0.20250523034308-74f78ae071ee // indirect
github.com/pingcap/failpoint v0.0.0-20240528011301-b51a646c7c86 // indirect
github.com/pingcap/log v1.1.0 // indirect
github.com/pingcap/tidb/pkg/parser v0.0.0-20260418072757-ce92298d1124 // indirect
github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c // indirect
github.com/pressly/goose/v3 v3.30.0 // indirect
github.com/prometheus/client_golang v1.12.1 // indirect
github.com/prometheus/client_model v0.2.0 // indirect
github.com/prometheus/common v0.32.1 // indirect
github.com/prometheus/procfs v0.23.0 // indirect
github.com/quasilyte/go-ruleguard v0.4.5 // indirect
github.com/quasilyte/go-ruleguard/dsl v0.3.23 // indirect
github.com/quasilyte/gogrep v0.5.0 // indirect
github.com/quasilyte/regex/syntax v0.0.0-20210819130434-b3f0c404a727 // indirect
github.com/quasilyte/stdinfo v0.0.0-20220114132959-f7386bf02567 // indirect
github.com/raeperd/recvcheck v0.3.1 // indirect
github.com/redis/go-redis/v9 v9.23.0 // indirect
github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
github.com/rivo/uniseg v0.4.7 // indirect
github.com/riza-io/grpc-go v0.2.0 // indirect
github.com/rogpeppe/go-internal v1.16.0 // indirect
github.com/ryancurrah/gomodguard v1.4.1 // indirect
github.com/ryancurrah/gomodguard/v2 v2.1.3 // indirect
github.com/ryanrolds/sqlclosecheck v0.6.0 // indirect
github.com/sagikazarmark/locafero v0.11.0 // indirect
github.com/sanposhiho/wastedassign/v2 v2.1.0 // indirect
github.com/santhosh-tekuri/jsonschema/v6 v6.0.3 // indirect
github.com/sashamelentyev/interfacebloat v1.1.0 // indirect
github.com/sashamelentyev/usestdlibvars v1.29.0 // indirect
github.com/securego/gosec/v2 v2.29.0 // indirect
github.com/segmentio/asm v1.2.1 // indirect
github.com/sethvargo/go-retry v0.5.0 // indirect
github.com/shopspring/decimal v1.6.0 // indirect
github.com/sirupsen/logrus v1.10.2 // indirect
github.com/sivchari/containedctx v1.0.3 // indirect
github.com/sonatard/noctx v0.5.1 // indirect
github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8 // indirect
github.com/sourcegraph/go-diff v0.9.0 // indirect
github.com/speakeasy-api/jsonpath v0.6.3 // indirect
github.com/speakeasy-api/openapi v1.24.0 // indirect
github.com/spf13/afero v1.15.0 // indirect
github.com/spf13/cast v1.10.0 // indirect
github.com/spf13/cobra v1.10.2 // indirect
github.com/spf13/pflag v1.0.10 // indirect
github.com/sqlc-dev/doubleclick v1.0.0 // indirect
github.com/sqlc-dev/sqlc v1.31.1 // indirect
github.com/ssgreg/nlreturn/v2 v2.2.1 // indirect
github.com/stbenjam/no-sprintf-host-port v0.3.1 // indirect
github.com/stretchr/objx v0.5.3 // indirect
github.com/stretchr/testify v1.12.1 // indirect
github.com/subosito/gotenv v1.6.0 // indirect
github.com/tetafro/godot v1.5.6 // indirect
github.com/tetratelabs/wazero v1.11.0 // indirect
github.com/timakin/bodyclose v0.0.0-20260723120731-857993a2939c // indirect
github.com/timonwong/loggercheck v0.12.0 // indirect
github.com/tomarrell/wrapcheck/v2 v2.12.0 // indirect
github.com/tommy-muehle/go-mnd/v2 v2.5.1 // indirect
github.com/tursodatabase/libsql-client-go v0.0.0-20260528064733-9d5d30a29a60 // indirect
github.com/ultraware/funlen v0.2.0 // indirect
github.com/ultraware/whitespace v0.2.0 // indirect
github.com/uudashr/gocognit v1.2.1 // indirect
github.com/uudashr/iface v1.5.1 // indirect
github.com/vertica/vertica-sql-go v1.3.9 // indirect
github.com/vmware-labs/yaml-jsonpath v0.3.2 // indirect
github.com/wasilibs/go-pgquery v0.0.0-20250409022910-10ac41983c07 // indirect
github.com/wasilibs/wazero-helpers v0.0.0-20240620070341-3dff1577cd52 // indirect
github.com/xen0n/gosmopolitan v1.3.0 // indirect
github.com/xo/terminfo v1.0.0 // indirect
github.com/yagipy/maintidx v1.0.0 // indirect
github.com/yandex-cloud/go-genproto v0.137.0 // indirect
github.com/ydb-platform/ydb-go-genproto v0.0.0-20260810123728-f0c151ab31b9 // indirect
github.com/ydb-platform/ydb-go-sdk-auth-environ v0.5.3 // indirect
github.com/ydb-platform/ydb-go-sdk/v3 v3.156.1 // indirect
github.com/ydb-platform/ydb-go-yc v0.12.5 // indirect
github.com/ydb-platform/ydb-go-yc-metadata v0.6.2 // indirect
github.com/yeya24/promlinter v0.3.0 // indirect
github.com/ykadowak/zerologlint v0.1.5 // indirect
github.com/ziutek/mymysql v1.5.4 // indirect
gitlab.com/bosi/decorder v0.4.2 // indirect
go-simpler.org/musttag v0.14.0 // indirect
go-simpler.org/sloglint v0.12.0 // indirect
go.augendre.info/arangolint v0.4.0 // indirect
go.augendre.info/fatcontext v0.10.1 // indirect
go.opentelemetry.io/otel v1.47.0 // indirect
go.opentelemetry.io/otel/trace v1.47.0 // indirect
go.uber.org/atomic v1.12.0 // indirect
go.uber.org/multierr v1.11.0 // indirect
go.uber.org/zap v1.28.0 // indirect
go.yaml.in/yaml/v3 v3.0.6 // indirect
golang.org/x/crypto v0.59.0 // indirect
golang.org/x/exp v0.0.0-20261109185158-a52e3aef5920 // indirect
golang.org/x/exp/typeparams v0.0.0-20260811152304-ee035b5b010f // indirect
golang.org/x/mod v0.42.0 // indirect
golang.org/x/net v0.62.0 // indirect
golang.org/x/sync v0.25.0 // indirect
golang.org/x/sys v0.50.0 // indirect
golang.org/x/text v0.44.0 // indirect
golang.org/x/tools v0.52.1-0.20261106145633-d407941a339a // indirect
google.golang.org/genproto/googleapis/api v0.0.0-20261110000943-09e21b237f2c // indirect
google.golang.org/genproto/googleapis/rpc v0.0.0-20261110000943-09e21b237f2c // indirect
google.golang.org/grpc v1.85.0 // indirect
google.golang.org/protobuf v1.36.12 // indirect
gopkg.in/natefinch/lumberjack.v2 v2.2.1 // indirect
gopkg.in/yaml.v3 v3.0.1 // indirect
honnef.co/go/tools v0.8.1 // indirect
howett.net/plist v1.0.1 // indirect
modernc.org/libc v1.80.2 // indirect
modernc.org/mathutil v1.7.1 // indirect
modernc.org/memory v1.12.1 // indirect
modernc.org/sqlite v1.62.0 // indirect
mvdan.cc/gofumpt v0.12.0 // indirect
mvdan.cc/unparam v0.0.0-20260823230713-2fa3d841b0c8 // indirect
)
+1275
View File
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
+100
View File
@@ -0,0 +1,100 @@
package handler
import (
"context"
"backend/internal/domain/model"
)
// Реализация StrictServerInterface: вызвать use-case и перевести результат в
// API-модели. Ошибки уходят в writeError, он один решает про HTTP-статус.
func (h *API) Liveness(context.Context, LivenessRequestObject) (LivenessResponseObject, error) {
return Liveness200JSONResponse{Body: Health{Status: Ok}}, nil
}
// Readiness rejects draining instances and unavailable required dependencies.
func (h *API) Readiness(ctx context.Context, _ ReadinessRequestObject) (ReadinessResponseObject, error) {
if !h.ready.Load() {
return nil, errDraining
}
if err := h.probe(ctx); err != nil {
return nil, model.ErrUnavailable
}
return Readiness200JSONResponse{Body: Health{Status: Ok}}, nil
}
func (h *API) RegisterUser(ctx context.Context, req RegisterUserRequestObject) (RegisterUserResponseObject, error) {
if req.Body.Password == nil {
return nil, &model.ValidationError{Message: "password is required"}
}
user, err := h.auth.Register(ctx, req.Body.Username, req.Body.DisplayName, *req.Body.Password)
if err != nil {
return nil, err
}
return RegisterUser201JSONResponse{Body: toUser(user)}, nil
}
func (h *API) CurrentUser(ctx context.Context, _ CurrentUserRequestObject) (CurrentUserResponseObject, error) {
return CurrentUser200JSONResponse{Body: toUser(currentUser(ctx))}, nil
}
func (h *API) CreateChat(ctx context.Context, req CreateChatRequestObject) (CreateChatResponseObject, error) {
chat, err := h.app.CreateChat(ctx, currentUser(ctx).ID, req.Body.Title, req.Body.MemberIds)
if err != nil {
return nil, err
}
return CreateChat201JSONResponse{Body: toChat(chat)}, nil
}
func (h *API) ListChats(ctx context.Context, req ListChatsRequestObject) (ListChatsResponseObject, error) {
page, err := h.app.ListChats(ctx, currentUser(ctx).ID, req.Params.Limit, req.Params.Cursor)
if err != nil {
return nil, err
}
return ListChats200JSONResponse{Body: ChatPage{Items: mapAll(page.Items, toChat), NextCursor: page.NextCursor}}, nil
}
func (h *API) GetChat(ctx context.Context, req GetChatRequestObject) (GetChatResponseObject, error) {
chat, err := h.app.GetChat(ctx, currentUser(ctx).ID, req.ChatId)
if err != nil {
return nil, err
}
return GetChat200JSONResponse{Body: toChat(chat)}, nil
}
func (h *API) CreateMessage(ctx context.Context, req CreateMessageRequestObject) (CreateMessageResponseObject, error) {
msg, err := h.app.SendMessage(ctx, currentUser(ctx).ID, req.ChatId, req.Body.Text)
if err != nil {
return nil, err
}
return CreateMessage201JSONResponse{Body: toMessage(msg)}, nil
}
func (h *API) ListMessages(ctx context.Context, req ListMessagesRequestObject) (ListMessagesResponseObject, error) {
page, err := h.app.ListMessages(ctx, currentUser(ctx).ID, req.ChatId, req.Params.Limit, req.Params.Cursor)
if err != nil {
return nil, err
}
return ListMessages200JSONResponse{Body: MessagePage{Items: mapAll(page.Items, toMessage), NextCursor: page.NextCursor}}, nil
}
func toUser(u model.User) User {
return User{Id: u.ID, Username: u.Username, DisplayName: u.DisplayName, CreatedAt: Timestamp(u.CreatedAt)}
}
func toChat(c model.Chat) Chat {
return Chat{Id: c.ID, Title: c.Title, MemberIds: c.MemberIDs, CreatedAt: Timestamp(c.CreatedAt)}
}
func toMessage(m model.Message) Message {
return Message{Id: m.ID, ChatId: m.ChatID, SenderId: m.SenderID, Text: m.Text, CreatedAt: Timestamp(m.CreatedAt)}
}
func mapAll[T, R any](items []T, f func(T) R) []R {
out := make([]R, len(items))
for i, item := range items {
out[i] = f(item)
}
return out
}
+43
View File
@@ -0,0 +1,43 @@
package handler
import (
"backend/internal/domain/model"
"context"
"net/http"
"strings"
"time"
"unicode/utf8"
)
type sessionRequestKey struct{}
func (h *API) CreateSession(ctx context.Context, _ CreateSessionRequestObject) (CreateSessionResponseObject, error) {
r := ctx.Value(sessionRequestKey{}).(*http.Request)
username, password, ok := r.BasicAuth()
if !ok || len(username) > 32 || len(password) > 512 || utf8.RuneCountInString(password) > 128 {
return nil, model.ErrUnauthorized
}
s, err := h.auth.Login(ctx, username, password)
if err != nil {
return nil, err
}
return CreateSession201JSONResponse{Body: Session{Token: s.Token, TokenType: Bearer, ExpiresAt: Timestamp(s.ExpiresAt), User: toUser(s.User)}}, nil
}
func (h *API) RevokeSession(ctx context.Context, _ RevokeSessionRequestObject) (RevokeSessionResponseObject, error) {
r := ctx.Value(sessionRequestKey{}).(*http.Request)
parts := strings.Fields(r.Header.Get("Authorization"))
if err := h.auth.Logout(ctx, parts[1]); err != nil {
return nil, err
}
return RevokeSession204Response{}, nil
}
func (h *API) requestContext(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
ctx, cancel := context.WithTimeout(r.Context(), 5*time.Second)
defer cancel()
if r.URL.Path == "/api/v1/auth/sessions" {
w.Header().Set("WWW-Authenticate", `Basic realm="messenger", charset="UTF-8"`)
}
next.ServeHTTP(w, r.WithContext(context.WithValue(ctx, sessionRequestKey{}, r)))
})
}
@@ -0,0 +1,82 @@
package handler
import (
"encoding/json"
"errors"
"net/http"
"backend/internal/domain/model"
)
var (
errRouteNotFound = errors.New("route not found")
errMethodNotAllowed = errors.New("method not allowed")
errPayloadTooLarge = errors.New("payload too large")
errOverloaded = errors.New("overloaded")
errDraining = errors.New("draining")
)
type apiError struct {
status int
code ErrorErrorCode
message string
}
// classify — единственное место, где ошибка превращается в HTTP-статус.
func classify(err error) apiError {
var invalid *model.ValidationError
switch {
case errors.As(err, &invalid):
return apiError{http.StatusBadRequest, InvalidRequest, invalid.Message}
case errors.Is(err, model.ErrUnauthorized):
return apiError{http.StatusUnauthorized, Unauthorized, "нужна действующая сессия"}
case errors.Is(err, model.ErrNotFound), errors.Is(err, errRouteNotFound):
return apiError{http.StatusNotFound, NotFound, "объект не найден"}
case errors.Is(err, errMethodNotAllowed):
return apiError{http.StatusMethodNotAllowed, InvalidRequest, "метод не поддерживается"}
case errors.Is(err, model.ErrUsernameTaken):
return apiError{http.StatusConflict, Conflict, "username уже занят"}
case errors.Is(err, model.ErrConflict):
return apiError{http.StatusConflict, Conflict, "конфликт запроса"}
case errors.Is(err, model.ErrUnavailable):
return apiError{http.StatusServiceUnavailable, Unavailable, "зависимость недоступна"}
case errors.Is(err, errPayloadTooLarge):
return apiError{http.StatusRequestEntityTooLarge, PayloadTooLarge, "тело запроса больше допустимого"}
case errors.Is(err, model.ErrStorageFull):
return apiError{http.StatusServiceUnavailable, Unavailable, "хранилище заполнено, запись невозможна; чтение работает"}
case errors.Is(err, errOverloaded):
return apiError{http.StatusServiceUnavailable, Unavailable, "сервер перегружен, повторите позже"}
case errors.Is(err, errDraining):
return apiError{http.StatusServiceUnavailable, Unavailable, "сервер останавливается"}
default:
return apiError{http.StatusInternalServerError, InternalError, "внутренняя ошибка"}
}
}
func (h *API) writeError(w http.ResponseWriter, r *http.Request, err error) {
e := classify(err)
if e.status == http.StatusInternalServerError {
h.log.Error().Err(err).Str("request_id", requestIDFrom(r.Context())).Msg("unexpected error")
}
if errors.Is(err, errOverloaded) {
w.Header().Set("Retry-After", "1")
}
var body Error
body.Error.Code = e.code
body.Error.Message = e.message
body.Error.RequestId = requestIDFrom(r.Context())
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(e.status)
_ = json.NewEncoder(w).Encode(body)
}
// bodyError — JSON синтаксически верен (это проверил jsonBody), но не
// подходит к схеме: лишнее поле или неверный тип.
func (h *API) bodyError(w http.ResponseWriter, r *http.Request, _ error) {
h.writeError(w, r, &model.ValidationError{Message: "тело запроса не соответствует схеме: лишнее поле или неверный тип"})
}
// paramError — path или query параметр не разобрался (UUID, целое число).
func (h *API) paramError(w http.ResponseWriter, r *http.Request, _ error) {
h.writeError(w, r, &model.ValidationError{Message: "некорректный параметр запроса"})
}
+78
View File
@@ -0,0 +1,78 @@
package handler
import (
"net/http"
"sync/atomic"
"time"
)
// gate ограничивает одновременную обработку запросов API: не больше inflight
// в работе и не больше queue в ожидании слота. Лишние сразу получают 503 с
// Retry-After, ждавшие дольше timeout — тоже 503. Так перегрузка превращается
// в быстрый предсказуемый отказ, а не в рост горутин, памяти и задержки.
type gate struct {
slots chan struct{} // nil — без лимита
maxQueue int64
timeout time.Duration
waiting atomic.Int64
rejected atomic.Int64
}
func newGate(inflight, queue int, timeout time.Duration) *gate {
g := &gate{maxQueue: int64(queue), timeout: timeout}
if inflight > 0 {
g.slots = make(chan struct{}, inflight)
}
return g
}
func (g *gate) middleware(reject func(http.ResponseWriter, *http.Request, error)) func(http.Handler) http.Handler {
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if g.slots == nil {
next.ServeHTTP(w, r)
return
}
if !g.acquire(r) {
g.rejected.Add(1)
reject(w, r, errOverloaded)
return
}
defer func() { <-g.slots }()
next.ServeHTTP(w, r)
})
}
}
func (g *gate) acquire(r *http.Request) bool {
select {
case g.slots <- struct{}{}:
return true
default:
}
if g.waiting.Add(1) > g.maxQueue {
g.waiting.Add(-1)
return false
}
defer g.waiting.Add(-1)
timer := time.NewTimer(g.timeout)
defer timer.Stop()
select {
case g.slots <- struct{}{}:
return true
case <-timer.C:
return false
case <-r.Context().Done():
return false
}
}
type gateStats struct {
Inflight int `json:"inflight"`
Waiting int64 `json:"waiting"`
Rejected int64 `json:"rejected"`
}
func (g *gate) stats() gateStats {
return gateStats{Inflight: len(g.slots), Waiting: g.waiting.Load(), Rejected: g.rejected.Load()}
}
@@ -0,0 +1,102 @@
package handler
import (
"errors"
"net/http"
"net/http/httptest"
"sync"
"testing"
"time"
)
// gatedServer пропускает запросы через gate в обработчик, который держит слот,
// пока тест не закроет release.
func gatedServer(t *testing.T, g *gate) (*httptest.Server, chan struct{}, chan struct{}) {
t.Helper()
entered, release := make(chan struct{}, 10), make(chan struct{})
reject := func(w http.ResponseWriter, _ *http.Request, err error) {
if !errors.Is(err, errOverloaded) {
t.Errorf("unexpected error %v", err)
}
w.Header().Set("Retry-After", "1")
w.WriteHeader(http.StatusServiceUnavailable)
}
h := g.middleware(reject)(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
entered <- struct{}{}
<-release
w.WriteHeader(http.StatusOK)
}))
srv := httptest.NewServer(h)
t.Cleanup(srv.Close)
return srv, entered, release
}
func get(t *testing.T, url string) int {
t.Helper()
resp, err := http.Get(url)
if err != nil {
t.Error(err)
return 0
}
resp.Body.Close()
return resp.StatusCode
}
func waitFor(t *testing.T, cond func() bool) {
t.Helper()
deadline := time.Now().Add(2 * time.Second)
for !cond() {
if time.Now().After(deadline) {
t.Fatal("condition not reached")
}
time.Sleep(time.Millisecond)
}
}
func TestGateRejectsBeyondQueueAndRecovers(t *testing.T) {
t.Parallel()
g := newGate(1, 1, time.Minute)
srv, entered, release := gatedServer(t, g)
statuses := make(chan int, 2)
var wg sync.WaitGroup
wg.Go(func() { statuses <- get(t, srv.URL) }) // занимает слот
<-entered
wg.Go(func() { statuses <- get(t, srv.URL) }) // ждёт в очереди
waitFor(t, func() bool { return g.waiting.Load() == 1 })
if code := get(t, srv.URL); code != http.StatusServiceUnavailable {
t.Fatalf("third request: %d, want 503", code)
}
close(release)
wg.Wait()
close(statuses)
for code := range statuses {
if code != http.StatusOK {
t.Fatalf("admitted request got %d", code)
}
}
if code := get(t, srv.URL); code != http.StatusOK {
t.Fatalf("after load: %d, want recovery to 200", code)
}
if g.stats().Rejected != 1 {
t.Fatalf("rejected %d", g.stats().Rejected)
}
}
func TestGateTimesOutQueuedRequest(t *testing.T) {
t.Parallel()
g := newGate(1, 10, 20*time.Millisecond)
srv, entered, release := gatedServer(t, g)
defer close(release)
go get(t, srv.URL)
<-entered
start := time.Now()
if code := get(t, srv.URL); code != http.StatusServiceUnavailable {
t.Fatalf("queued request: %d, want 503 after timeout", code)
}
if time.Since(start) > time.Second {
t.Fatal("queue timeout not applied")
}
}
@@ -0,0 +1,95 @@
package handler
import (
"context"
"net/http"
"sync/atomic"
"time"
"backend/internal/application/usecase"
"github.com/go-chi/chi/v5"
"github.com/rs/zerolog"
)
// Limits — защитные лимиты HTTP-слоя (трек 5 «управляемая деградация»).
// Нулевое значение отключает лимит.
type Limits struct {
MaxBodyBytes int64 // больше — 413
MaxInflight int // одновременно обрабатываемые запросы API
MaxQueue int // ждущие свободного слота; больше — сразу 503
QueueTimeout time.Duration // дольше ждал слот — 503
}
// API — driving HTTP-адаптер: реализует StrictServerInterface из api.gen.go.
//
//go:generate go tool oapi-codegen -config ../../../codegen.yaml ../../../../contracts/openapi.json
type API struct {
app *usecase.Messenger
auth *usecase.Auth
probe func(context.Context) error
limits Limits
gate *gate
storeStats func() any
ready atomic.Bool
log *zerolog.Logger
}
// New собирает HTTP-адаптер. storeStats отдаёт состояние хранилища для
// /debug/stats.
func New(app *usecase.Messenger, auth *usecase.Auth, probe func(context.Context) error, limits Limits, storeStats func() any, log *zerolog.Logger) *API {
h := &API{
app: app,
auth: auth,
probe: probe,
limits: limits,
gate: newGate(limits.MaxInflight, limits.MaxQueue, limits.QueueTimeout),
storeStats: storeStats,
log: log,
}
h.ready.Store(true)
return h
}
// Drain переводит /health/ready в 503 перед остановкой сервера.
func (h *API) Drain() { h.ready.Store(false) }
func (h *API) Router() http.Handler {
r := chi.NewRouter()
r.Use(requestID, h.recoverer, h.accessLog, h.requestContext)
r.NotFound(func(w http.ResponseWriter, r *http.Request) {
h.writeError(w, r, errRouteNotFound)
})
r.MethodNotAllowed(func(w http.ResponseWriter, r *http.Request) {
h.writeError(w, r, errMethodNotAllowed)
})
strict := NewStrictHandlerWithOptions(h, nil, StrictHTTPServerOptions{
RequestErrorHandlerFunc: h.bodyError,
ResponseErrorHandlerFunc: h.writeError,
})
api := ServerInterfaceWrapper{Handler: strict, ErrorHandlerFunc: h.paramError}
// Health и статистика — мимо очереди: под перегрузкой они должны отвечать.
r.Get("/health/live", api.Liveness)
r.Get("/health/ready", api.Readiness)
r.Get("/debug/stats", h.stats)
r.Route("/api/v1", func(r chi.Router) {
r.Use(h.gate.middleware(h.writeError))
r.With(h.jsonBody).Post("/users", api.RegisterUser)
r.Post("/auth/sessions", api.CreateSession)
// Сначала аутентификация, потом тело и доступ к ресурсу.
r.Group(func(r chi.Router) {
r.Use(h.authenticate, h.validQuery, h.jsonBody)
r.Delete("/auth/sessions/current", api.RevokeSession)
r.Get("/users/me", api.CurrentUser)
r.Post("/chats", api.CreateChat)
r.Get("/chats", api.ListChats)
r.Get("/chats/{chat_id}", api.GetChat)
r.Post("/chats/{chat_id}/messages", api.CreateMessage)
r.Get("/chats/{chat_id}/messages", api.ListMessages)
})
})
return r
}
+53
View File
@@ -0,0 +1,53 @@
package handler
import (
"bytes"
"encoding/json"
"time"
)
// Timestamp подставляется кодогенератором вместо time.Time (codegen.yaml,
// type-mapping): RFC 3339 UTC с ровно шестью цифрами дробной части.
// time.Time срезает хвостовые нули, а fromisoformat в Python 3.9–3.10
// (на нём публичные тесты) понимает дробную часть только из 3 или 6 цифр.
type Timestamp time.Time
const timestampLayout = "2006-01-02T15:04:05.000000Z"
func (t Timestamp) MarshalJSON() ([]byte, error) {
return []byte(`"` + time.Time(t).UTC().Format(timestampLayout) + `"`), nil
}
func (t *Timestamp) UnmarshalJSON(data []byte) error {
var parsed time.Time
if err := json.Unmarshal(data, &parsed); err != nil {
return err
}
*t = Timestamp(parsed)
return nil
}
// Тела запросов с лишними полями — 400 по контракту, а сгенерированный
// декодер их молча игнорирует. Строгий разбор подключается методами на
// сгенерированных типах.
func (c *CreateUser) UnmarshalJSON(data []byte) error {
type plain CreateUser
return decodeStrict(data, (*plain)(c))
}
func (c *CreateChat) UnmarshalJSON(data []byte) error {
type plain CreateChat
return decodeStrict(data, (*plain)(c))
}
func (c *CreateMessage) UnmarshalJSON(data []byte) error {
type plain CreateMessage
return decodeStrict(data, (*plain)(c))
}
func decodeStrict(data []byte, dst any) error {
dec := json.NewDecoder(bytes.NewReader(data))
dec.DisallowUnknownFields()
return dec.Decode(dst)
}
@@ -0,0 +1,155 @@
package handler
import (
"bytes"
"context"
"encoding/json"
"errors"
"io"
"net/http"
"net/url"
"runtime/debug"
"strings"
"time"
"unicode/utf8"
"backend/internal/domain/model"
"github.com/go-chi/chi/v5"
"github.com/go-chi/chi/v5/middleware"
"github.com/google/uuid"
)
type ctxKey int
const (
requestIDKey ctxKey = iota
userKey
)
// requestID ставит X-Request-Id в каждый ответ, включая ошибки и health.
func requestID(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
id := uuid.NewString()
w.Header().Set("X-Request-Id", id)
next.ServeHTTP(w, r.WithContext(context.WithValue(r.Context(), requestIDKey, id)))
})
}
func requestIDFrom(ctx context.Context) string {
id, _ := ctx.Value(requestIDKey).(string)
return id
}
// recoverer превращает панику в 500 без деталей; стек — только в лог.
func (h *API) recoverer(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
defer func() {
rec := recover()
if rec == nil {
return
}
if rec == http.ErrAbortHandler {
panic(rec)
}
h.log.Error().Interface("panic", rec).Bytes("stack", debug.Stack()).
Str("request_id", requestIDFrom(r.Context())).Msg("panic")
h.writeError(w, r, errors.New("panic"))
}()
next.ServeHTTP(w, r)
})
}
// accessLog пишет метод, шаблон маршрута, статус и длительность. Тело, query
// и заголовки не логируются: там текст сообщений и идентификаторы.
func (h *API) accessLog(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
start := time.Now()
ww := middleware.NewWrapResponseWriter(w, r.ProtoMajor)
next.ServeHTTP(ww, r)
route := chi.RouteContext(r.Context()).RoutePattern()
if route == "" {
route = "unmatched"
}
event := h.log.Info()
if ww.Status() >= http.StatusInternalServerError {
event = h.log.Warn()
}
event.Str("request_id", requestIDFrom(r.Context())).
Str("method", r.Method).
Str("route", route).
Int("status", ww.Status()).
Dur("duration", time.Since(start)).
Msg("request")
})
}
// authenticate verifies persisted Bearer sessions for protected business routes.
// The session-creation endpoint separately validates Basic credentials.
func (h *API) authenticate(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
parts := strings.Fields(r.Header.Get("Authorization"))
if len(parts) != 2 || !strings.EqualFold(parts[0], "Bearer") {
w.Header().Set("WWW-Authenticate", `Bearer realm="messenger"`)
h.writeError(w, r, model.ErrUnauthorized)
return
}
user, err := h.auth.Authenticate(r.Context(), parts[1])
if err != nil {
if errors.Is(err, model.ErrUnauthorized) {
w.Header().Set("WWW-Authenticate", `Bearer realm="messenger"`)
}
h.writeError(w, r, err)
return
}
next.ServeHTTP(w, r.WithContext(context.WithValue(r.Context(), userKey, user)))
})
}
// validQuery отсекает query с битым %-экранированием: url.Values молча
// выбросил бы такой параметр, и cursor=%%% превратился бы в «с начала».
func (h *API) validQuery(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if _, err := url.ParseQuery(r.URL.RawQuery); err != nil {
h.writeError(w, r, &model.ValidationError{Message: "некорректная строка запроса"})
return
}
next.ServeHTTP(w, r)
})
}
func currentUser(ctx context.Context) model.User {
user, _ := ctx.Value(userKey).(model.User)
return user
}
// jsonBody читает тело POST с лимитом размера (иначе 413) и отсекает
// синтаксически неверный JSON (400) до кодогенерированного декодера: тот
// читает только первое JSON-значение и пропустил бы мусор после него.
func (h *API) jsonBody(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodPost {
next.ServeHTTP(w, r)
return
}
reader := io.Reader(r.Body)
if h.limits.MaxBodyBytes > 0 {
reader = http.MaxBytesReader(w, r.Body, h.limits.MaxBodyBytes)
}
body, err := io.ReadAll(reader)
var tooLarge *http.MaxBytesError
switch {
case errors.As(err, &tooLarge):
h.writeError(w, r, errPayloadTooLarge)
return
case err != nil:
h.writeError(w, r, &model.ValidationError{Message: "тело запроса не прочитано"})
return
case !utf8.Valid(body)||!json.Valid(body):
h.writeError(w, r, &model.ValidationError{Message: "некорректный JSON"})
return
}
r.Body = io.NopCloser(bytes.NewReader(body))
next.ServeHTTP(w, r)
})
}
+47
View File
@@ -0,0 +1,47 @@
package handler
import (
"bufio"
"encoding/json"
"net/http"
"os"
"runtime"
"runtime/debug"
"strconv"
"strings"
)
// stats — расширение за пределами контракта (contracts/extensions.md): память
// процесса, учтённый объём хранилища и очередь. Нужен для графиков трека 5.
func (h *API) stats(w http.ResponseWriter, _ *http.Request) {
var mem runtime.MemStats
runtime.ReadMemStats(&mem)
w.Header().Set("Content-Type", "application/json")
_ = json.NewEncoder(w).Encode(map[string]any{
"rss_bytes": rssBytes(),
"heap_alloc": mem.HeapAlloc,
"heap_sys": mem.HeapSys,
"go_memory_limit": debug.SetMemoryLimit(-1),
"num_gc": mem.NumGC,
"goroutines": runtime.NumGoroutine(),
"gate": h.gate.stats(),
"store": h.storeStats(),
})
}
// rssBytes читает VmRSS из /proc (только Linux, то есть в контейнере); иначе 0.
func rssBytes() int64 {
f, err := os.Open("/proc/self/status")
if err != nil {
return 0
}
defer f.Close()
sc := bufio.NewScanner(f)
for sc.Scan() {
if kb, ok := strings.CutPrefix(sc.Text(), "VmRSS:"); ok {
n, _ := strconv.ParseInt(strings.TrimSpace(strings.TrimSuffix(kb, "kB")), 10, 64)
return n * 1024
}
}
return 0
}
@@ -0,0 +1,9 @@
package handler
import("bytes";"net/http";"net/http/httptest";"testing")
func TestRejectsInvalidUTF8BeforeJSONDecoding(t *testing.T){
body:=append([]byte(`{"display_name":"`),0xff);body=append(body,[]byte(`"}`)...)
request:=httptest.NewRequest(http.MethodPost,"/api/v1/users",bytes.NewReader(body));response:=httptest.NewRecorder()
h:=&API{limits:Limits{MaxBodyBytes:65536}};called:=false
requestID(h.jsonBody(http.HandlerFunc(func(w http.ResponseWriter,r *http.Request){called=true;w.WriteHeader(204)}))).ServeHTTP(response,request)
if response.Code!=400||called{t.Fatalf("invalid UTF-8 reached decoder: status=%d called=%t",response.Code,called)}
}
@@ -0,0 +1,36 @@
package password
import (
"backend/internal/domain/port"
"crypto/rand"
"crypto/subtle"
"encoding/base64"
"fmt"
"golang.org/x/crypto/argon2"
"strings"
)
type Argon struct{}
func New() port.Passwords { return Argon{} }
func (Argon) Hash(password string) (string, error) {
salt := make([]byte, 16)
if _, err := rand.Read(salt); err != nil {
return "", err
}
hash := argon2.IDKey([]byte(password), salt, 2, 32*1024, 1, 32)
return fmt.Sprintf("argon2id$v19$m32768t2p1$%s$%s", base64.RawStdEncoding.EncodeToString(salt), base64.RawStdEncoding.EncodeToString(hash)), nil
}
func (Argon) Verify(password, encoded string) bool {
parts := strings.Split(encoded, "$")
if len(parts) != 5 || parts[0] != "argon2id" || parts[1] != "v19" || parts[2] != "m32768t2p1" {
return false
}
salt, e1 := base64.RawStdEncoding.DecodeString(parts[3])
want, e2 := base64.RawStdEncoding.DecodeString(parts[4])
if e1 != nil || e2 != nil || len(salt) != 16 || len(want) != 32 {
return false
}
got := argon2.IDKey([]byte(password), salt, 2, 32*1024, 1, 32)
return subtle.ConstantTimeCompare(got, want) == 1
}
@@ -0,0 +1,347 @@
// Code generated by sqlc. DO NOT EDIT.
// versions:
// sqlc v1.31.1
// source: core.sql
package queries
import (
"context"
"time"
"github.com/google/uuid"
)
const authenticateSession = `-- name: AuthenticateSession :one
SELECT user_id FROM sessions WHERE token_hash=$1 AND expires_at>clock_timestamp()
`
func (q *Queries) AuthenticateSession(ctx context.Context, tokenHash string) (uuid.UUID, error) {
row := q.db.QueryRow(ctx, authenticateSession, tokenHash)
var user_id uuid.UUID
err := row.Scan(&user_id)
return user_id, err
}
const chargeChat = `-- name: ChargeChat :one
UPDATE users SET chat_count=chat_count+1 WHERE id=$1 AND chat_count<1000 RETURNING id
`
func (q *Queries) ChargeChat(ctx context.Context, id uuid.UUID) (uuid.UUID, error) {
row := q.db.QueryRow(ctx, chargeChat, id)
var id_2 uuid.UUID
err := row.Scan(&id_2)
return id_2, err
}
const chargeMessage = `-- name: ChargeMessage :one
UPDATE users SET message_count=message_count+1 WHERE id=$1 AND message_count<1000000 RETURNING id
`
func (q *Queries) ChargeMessage(ctx context.Context, id uuid.UUID) (uuid.UUID, error) {
row := q.db.QueryRow(ctx, chargeMessage, id)
var id_2 uuid.UUID
err := row.Scan(&id_2)
return id_2, err
}
const createUser = `-- name: CreateUser :one
INSERT INTO users(id,username,display_name,password_hash) VALUES($1,$2,$3,$4)
RETURNING id,username,display_name,created_at
`
type CreateUserParams struct {
ID uuid.UUID
Username string
DisplayName string
PasswordHash string
}
type CreateUserRow struct {
ID uuid.UUID
Username string
DisplayName string
CreatedAt time.Time
}
func (q *Queries) CreateUser(ctx context.Context, arg CreateUserParams) (CreateUserRow, error) {
row := q.db.QueryRow(ctx, createUser,
arg.ID,
arg.Username,
arg.DisplayName,
arg.PasswordHash,
)
var i CreateUserRow
err := row.Scan(
&i.ID,
&i.Username,
&i.DisplayName,
&i.CreatedAt,
)
return i, err
}
const credentials = `-- name: Credentials :one
SELECT id,password_hash FROM users WHERE username=$1
`
type CredentialsRow struct {
ID uuid.UUID
PasswordHash string
}
func (q *Queries) Credentials(ctx context.Context, username string) (CredentialsRow, error) {
row := q.db.QueryRow(ctx, credentials, username)
var i CredentialsRow
err := row.Scan(&i.ID, &i.PasswordHash)
return i, err
}
const deleteExpiredSessions = `-- name: DeleteExpiredSessions :exec
DELETE FROM sessions WHERE user_id=$1 AND expires_at<=clock_timestamp()
`
func (q *Queries) DeleteExpiredSessions(ctx context.Context, userID uuid.UUID) error {
_, err := q.db.Exec(ctx, deleteExpiredSessions, userID)
return err
}
const getChat = `-- name: GetChat :one
SELECT c.id,c.title,c.created_at,ARRAY(SELECT user_id FROM chat_members WHERE chat_id=c.id ORDER BY user_id)::uuid[] AS members
FROM chats c WHERE c.id=$1
`
type GetChatRow struct {
ID uuid.UUID
Title string
CreatedAt time.Time
Members []uuid.UUID
}
func (q *Queries) GetChat(ctx context.Context, id uuid.UUID) (GetChatRow, error) {
row := q.db.QueryRow(ctx, getChat, id)
var i GetChatRow
err := row.Scan(
&i.ID,
&i.Title,
&i.CreatedAt,
&i.Members,
)
return i, err
}
const getUser = `-- name: GetUser :one
SELECT id,username,display_name,created_at FROM users WHERE id=$1
`
type GetUserRow struct {
ID uuid.UUID
Username string
DisplayName string
CreatedAt time.Time
}
func (q *Queries) GetUser(ctx context.Context, id uuid.UUID) (GetUserRow, error) {
row := q.db.QueryRow(ctx, getUser, id)
var i GetUserRow
err := row.Scan(
&i.ID,
&i.Username,
&i.DisplayName,
&i.CreatedAt,
)
return i, err
}
const insertChat = `-- name: InsertChat :one
INSERT INTO chats(id,title) VALUES($1,$2) RETURNING id,title,created_at
`
type InsertChatParams struct {
ID uuid.UUID
Title string
}
func (q *Queries) InsertChat(ctx context.Context, arg InsertChatParams) (Chat, error) {
row := q.db.QueryRow(ctx, insertChat, arg.ID, arg.Title)
var i Chat
err := row.Scan(&i.ID, &i.Title, &i.CreatedAt)
return i, err
}
const insertMembers = `-- name: InsertMembers :exec
INSERT INTO chat_members(chat_id,user_id) SELECT $1,unnest($2::uuid[])
`
type InsertMembersParams struct {
ChatID uuid.UUID
Column2 []uuid.UUID
}
func (q *Queries) InsertMembers(ctx context.Context, arg InsertMembersParams) error {
_, err := q.db.Exec(ctx, insertMembers, arg.ChatID, arg.Column2)
return err
}
const insertMessage = `-- name: InsertMessage :one
INSERT INTO messages(id,chat_id,sender_id,text) VALUES($1,$2,$3,$4) RETURNING id,chat_id,sender_id,text,created_at
`
type InsertMessageParams struct {
ID uuid.UUID
ChatID uuid.UUID
SenderID uuid.UUID
Text string
}
func (q *Queries) InsertMessage(ctx context.Context, arg InsertMessageParams) (Message, error) {
row := q.db.QueryRow(ctx, insertMessage,
arg.ID,
arg.ChatID,
arg.SenderID,
arg.Text,
)
var i Message
err := row.Scan(
&i.ID,
&i.ChatID,
&i.SenderID,
&i.Text,
&i.CreatedAt,
)
return i, err
}
const insertSession = `-- name: InsertSession :one
INSERT INTO sessions(token_hash,user_id,expires_at)
SELECT $1,$2,$3 WHERE (SELECT count(*) FROM sessions WHERE user_id=$2)<100
RETURNING user_id
`
type InsertSessionParams struct {
TokenHash string
UserID uuid.UUID
ExpiresAt time.Time
}
func (q *Queries) InsertSession(ctx context.Context, arg InsertSessionParams) (uuid.UUID, error) {
row := q.db.QueryRow(ctx, insertSession, arg.TokenHash, arg.UserID, arg.ExpiresAt)
var user_id uuid.UUID
err := row.Scan(&user_id)
return user_id, err
}
const listChats = `-- name: ListChats :many
SELECT c.id,c.title,c.created_at,ARRAY(SELECT user_id FROM chat_members WHERE chat_id=c.id ORDER BY user_id)::uuid[] AS members
FROM chats c JOIN chat_members m ON m.chat_id=c.id
WHERE m.user_id=$1 AND (c.created_at,c.id)>($2::timestamptz,$3::uuid)
ORDER BY c.created_at,c.id LIMIT $4
`
type ListChatsParams struct {
MemberID uuid.UUID
AfterTime time.Time
AfterID uuid.UUID
PageLimit int32
}
type ListChatsRow struct {
ID uuid.UUID
Title string
CreatedAt time.Time
Members []uuid.UUID
}
func (q *Queries) ListChats(ctx context.Context, arg ListChatsParams) ([]ListChatsRow, error) {
rows, err := q.db.Query(ctx, listChats,
arg.MemberID,
arg.AfterTime,
arg.AfterID,
arg.PageLimit,
)
if err != nil {
return nil, err
}
defer rows.Close()
items := []ListChatsRow{}
for rows.Next() {
var i ListChatsRow
if err := rows.Scan(
&i.ID,
&i.Title,
&i.CreatedAt,
&i.Members,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const listMessages = `-- name: ListMessages :many
SELECT id,chat_id,sender_id,text,created_at FROM messages
WHERE chat_id=$1 AND (created_at,id)>($2::timestamptz,$3::uuid)
ORDER BY created_at,id LIMIT $4
`
type ListMessagesParams struct {
ChatID uuid.UUID
AfterTime time.Time
AfterID uuid.UUID
PageLimit int32
}
func (q *Queries) ListMessages(ctx context.Context, arg ListMessagesParams) ([]Message, error) {
rows, err := q.db.Query(ctx, listMessages,
arg.ChatID,
arg.AfterTime,
arg.AfterID,
arg.PageLimit,
)
if err != nil {
return nil, err
}
defer rows.Close()
items := []Message{}
for rows.Next() {
var i Message
if err := rows.Scan(
&i.ID,
&i.ChatID,
&i.SenderID,
&i.Text,
&i.CreatedAt,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const lockSessionOwner = `-- name: LockSessionOwner :one
SELECT id FROM users WHERE id=$1 FOR UPDATE
`
func (q *Queries) LockSessionOwner(ctx context.Context, id uuid.UUID) (uuid.UUID, error) {
row := q.db.QueryRow(ctx, lockSessionOwner, id)
var id_2 uuid.UUID
err := row.Scan(&id_2)
return id_2, err
}
const revokeSession = `-- name: RevokeSession :exec
DELETE FROM sessions WHERE token_hash=$1
`
func (q *Queries) RevokeSession(ctx context.Context, tokenHash string) error {
_, err := q.db.Exec(ctx, revokeSession, tokenHash)
return err
}
@@ -0,0 +1,32 @@
// Code generated by sqlc. DO NOT EDIT.
// versions:
// sqlc v1.31.1
package queries
import (
"context"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
)
type DBTX interface {
Exec(context.Context, string, ...interface{}) (pgconn.CommandTag, error)
Query(context.Context, string, ...interface{}) (pgx.Rows, error)
QueryRow(context.Context, string, ...interface{}) pgx.Row
}
func New(db DBTX) *Queries {
return &Queries{db: db}
}
type Queries struct {
db DBTX
}
func (q *Queries) WithTx(tx pgx.Tx) *Queries {
return &Queries{
db: tx,
}
}
@@ -0,0 +1,46 @@
// Code generated by sqlc. DO NOT EDIT.
// versions:
// sqlc v1.31.1
package queries
import (
"time"
"github.com/google/uuid"
)
type Chat struct {
ID uuid.UUID
Title string
CreatedAt time.Time
}
type ChatMember struct {
ChatID uuid.UUID
UserID uuid.UUID
}
type Message struct {
ID uuid.UUID
ChatID uuid.UUID
SenderID uuid.UUID
Text string
CreatedAt time.Time
}
type Session struct {
TokenHash string
UserID uuid.UUID
ExpiresAt time.Time
}
type User struct {
ID uuid.UUID
Username string
DisplayName string
PasswordHash string
CreatedAt time.Time
ChatCount int32
MessageCount int32
}
@@ -0,0 +1,207 @@
package postgres
import (
"context"
"encoding/json"
"errors"
"time"
"backend/internal/adapter/repository/postgres/queries"
"backend/internal/domain/model"
"backend/internal/domain/repository"
"github.com/google/uuid"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
"github.com/jackc/pgx/v5/pgxpool"
"github.com/redis/go-redis/v9"
)
//go:generate go tool sqlc generate -f ../../../../db/sqlc/sqlc.yaml
type Store struct {
pool *pgxpool.Pool
q *queries.Queries
cache *redis.Client
}
func New(pool *pgxpool.Pool, cache *redis.Client) repository.Persistent {
return &Store{pool, queries.New(pool), cache}
}
func mapErr(err error) error {
if err == nil {
return nil
}
if errors.Is(err, pgx.ErrNoRows) {
return model.ErrNotFound
}
var pg *pgconn.PgError
if errors.As(err, &pg) {
switch pg.Code {
case "23505":
return model.ErrUsernameTaken
case "23503":
return model.ErrUnknownMember
case "23514":
return &model.ValidationError{Message: "constraint violation"}
}
}
return model.ErrUnavailable
}
func (s *Store) CreateUser(ctx context.Context, d model.UserDraft) (model.User, error) {
row, err := s.q.CreateUser(ctx, queries.CreateUserParams{ID: uuid.New(), Username: d.Username, DisplayName: d.DisplayName, PasswordHash: d.PasswordHash})
return model.User{ID: row.ID, Username: row.Username, DisplayName: row.DisplayName, CreatedAt: row.CreatedAt}, mapErr(err)
}
func (s *Store) GetUser(ctx context.Context, id uuid.UUID) (model.User, error) {
key := "profile:" + id.String()
if s.cache != nil {
c, cancel := context.WithTimeout(ctx, 80*time.Millisecond)
raw, err := s.cache.Get(c, key).Bytes()
cancel()
if err == nil {
var u model.User
if json.Unmarshal(raw, &u) == nil && u.ID == id {
return u, nil
}
}
}
row, err := s.q.GetUser(ctx, id)
if err != nil {
return model.User{}, mapErr(err)
}
user := model.User{ID: row.ID, Username: row.Username, DisplayName: row.DisplayName, CreatedAt: row.CreatedAt}
if s.cache != nil {
raw, e := json.Marshal(user)
if e == nil {
c, cancel := context.WithTimeout(ctx, 80*time.Millisecond)
_ = s.cache.Set(c, key, raw, time.Minute).Err()
cancel()
}
}
return user, nil
}
func (s *Store) CreateChat(ctx context.Context, d model.ChatDraft) (model.Chat, error) {
tx, err := s.pool.Begin(ctx)
if err != nil {
return model.Chat{}, mapErr(err)
}
defer func() { _ = tx.Rollback(ctx) }()
q := s.q.WithTx(tx)
if _, err = q.ChargeChat(ctx, d.Creator); err != nil {
if errors.Is(err, pgx.ErrNoRows) {
return model.Chat{}, model.ErrStorageFull
}
return model.Chat{}, mapErr(err)
}
row, err := q.InsertChat(ctx, queries.InsertChatParams{ID: uuid.New(), Title: d.Title})
if err != nil {
return model.Chat{}, mapErr(err)
}
if err = q.InsertMembers(ctx, queries.InsertMembersParams{ChatID: row.ID, Column2: d.MemberIDs}); err != nil {
return model.Chat{}, mapErr(err)
}
if err = tx.Commit(ctx); err != nil {
return model.Chat{}, mapErr(err)
}
return model.Chat{ID: row.ID, Title: row.Title, CreatedAt: row.CreatedAt, MemberIDs: d.MemberIDs}, nil
}
func (s *Store) GetChat(ctx context.Context, id uuid.UUID) (model.Chat, error) {
r, e := s.q.GetChat(ctx, id)
return model.Chat{ID: r.ID, Title: r.Title, CreatedAt: r.CreatedAt, MemberIDs: r.Members}, mapErr(e)
}
func position(q model.PageQuery) (time.Time, uuid.UUID) {
if q.After == nil {
return time.Unix(0, 0).UTC(), uuid.Nil
}
return q.After.CreatedAt, q.After.ID
}
func (s *Store) ListChats(ctx context.Context, id uuid.UUID, p model.PageQuery) ([]model.Chat, bool, error) {
at, aid := position(p)
rows, err := s.q.ListChats(ctx, queries.ListChatsParams{MemberID: id, AfterTime: at, AfterID: aid, PageLimit: int32(p.Limit + 1)})
if err != nil {
return nil, false, mapErr(err)
}
more := len(rows) > p.Limit
if more {
rows = rows[:p.Limit]
}
out := make([]model.Chat, len(rows))
for i, r := range rows {
out[i] = model.Chat{ID: r.ID, Title: r.Title, CreatedAt: r.CreatedAt, MemberIDs: r.Members}
}
return out, more, nil
}
func (s *Store) CreateMessage(ctx context.Context, d model.MessageDraft) (model.Message, error) {
tx, err := s.pool.Begin(ctx)
if err != nil {
return model.Message{}, mapErr(err)
}
defer func() { _ = tx.Rollback(ctx) }()
q := s.q.WithTx(tx)
if _, err = q.ChargeMessage(ctx, d.SenderID); err != nil {
if errors.Is(err, pgx.ErrNoRows) {
return model.Message{}, model.ErrStorageFull
}
return model.Message{}, mapErr(err)
}
r, err := q.InsertMessage(ctx, queries.InsertMessageParams{ID: uuid.New(), ChatID: d.ChatID, SenderID: d.SenderID, Text: d.Text})
if err != nil {
return model.Message{}, mapErr(err)
}
if err = tx.Commit(ctx); err != nil {
return model.Message{}, mapErr(err)
}
return model.Message{ID: r.ID, ChatID: r.ChatID, SenderID: r.SenderID, Text: r.Text, CreatedAt: r.CreatedAt}, nil
}
func (s *Store) ListMessages(ctx context.Context, id uuid.UUID, p model.PageQuery) ([]model.Message, bool, error) {
at, aid := position(p)
rows, err := s.q.ListMessages(ctx, queries.ListMessagesParams{ChatID: id, AfterTime: at, AfterID: aid, PageLimit: int32(p.Limit + 1)})
if err != nil {
return nil, false, mapErr(err)
}
more := len(rows) > p.Limit
if more {
rows = rows[:p.Limit]
}
out := make([]model.Message, len(rows))
for i, r := range rows {
out[i] = model.Message{ID: r.ID, ChatID: r.ChatID, SenderID: r.SenderID, Text: r.Text, CreatedAt: r.CreatedAt}
}
return out, more, nil
}
func (s *Store) Credentials(ctx context.Context, name string) (uuid.UUID, string, error) {
r, e := s.q.Credentials(ctx, name)
if errors.Is(e, pgx.ErrNoRows) {
return uuid.Nil, "", model.ErrUnauthorized
}
return r.ID, r.PasswordHash, mapErr(e)
}
func (s *Store) CreateSession(ctx context.Context, hash string, id uuid.UUID, expiry time.Time) error {
tx, e := s.pool.Begin(ctx)
if e != nil {
return mapErr(e)
}
defer func() { _ = tx.Rollback(ctx) }()
q := s.q.WithTx(tx)
if _, e = q.LockSessionOwner(ctx, id); e != nil {
return mapErr(e)
}
if e = q.DeleteExpiredSessions(ctx, id); e != nil {
return mapErr(e)
}
if _, e = q.InsertSession(ctx, queries.InsertSessionParams{TokenHash: hash, UserID: id, ExpiresAt: expiry}); e != nil {
if errors.Is(e, pgx.ErrNoRows) {
return model.ErrStorageFull
}
return mapErr(e)
}
return mapErr(tx.Commit(ctx))
}
func (s *Store) AuthenticateSession(ctx context.Context, hash string) (uuid.UUID, error) {
r, e := s.q.AuthenticateSession(ctx, hash)
if errors.Is(e, pgx.ErrNoRows) {
return uuid.Nil, model.ErrUnauthorized
}
return r, mapErr(e)
}
func (s *Store) RevokeSession(ctx context.Context, hash string) error {
return mapErr(s.q.RevokeSession(ctx, hash))
}
@@ -0,0 +1,86 @@
package usecase
import (
"context"
"crypto/rand"
"crypto/sha256"
"encoding/base64"
"encoding/hex"
"time"
"unicode/utf8"
"backend/internal/domain/model"
"backend/internal/domain/port"
)
type Auth struct {
sessions port.Sessions
passwords port.Passwords
messenger *Messenger
ttl time.Duration
now func() time.Time
}
type Session struct {
Token string
ExpiresAt time.Time
User model.User
}
func NewAuth(s port.Sessions, p port.Passwords, m *Messenger, ttl time.Duration, now func() time.Time) *Auth {
return &Auth{s, p, m, ttl, now}
}
func (a *Auth) Register(ctx context.Context, username, name, password string) (model.User, error) {
if n := utf8.RuneCountInString(password); n < 12 || n > 128 || !utf8.ValidString(password) {
return model.User{}, &model.ValidationError{Message: "password: 12–128 Unicode characters"}
}
draft, err := model.NewUserDraft(username, name)
if err != nil {
return model.User{}, err
}
hash, err := a.passwords.Hash(password)
if err != nil {
return model.User{}, err
}
draft.PasswordHash = hash
return a.messenger.repo.CreateUser(ctx, draft)
}
func (a *Auth) Login(ctx context.Context, username, password string) (Session, error) {
id, hash, err := a.sessions.Credentials(ctx, username)
if err != nil {
return Session{}, err
}
if !a.passwords.Verify(password, hash) {
return Session{}, model.ErrUnauthorized
}
user, err := a.messenger.repo.GetUser(ctx, id)
if err != nil {
return Session{}, err
}
raw := make([]byte, 32)
if _, err = rand.Read(raw); err != nil {
return Session{}, err
}
token := base64.RawURLEncoding.EncodeToString(raw)
expires := a.now().UTC().Add(a.ttl)
if err = a.sessions.CreateSession(ctx, TokenHash(token), id, expires); err != nil {
return Session{}, err
}
return Session{token, expires, user}, nil
}
func TokenHash(token string) string {
sum := sha256.Sum256([]byte(token))
return hex.EncodeToString(sum[:])
}
func (a *Auth) Authenticate(ctx context.Context, token string) (model.User, error) {
if len(token) != 43 {
return model.User{}, model.ErrUnauthorized
}
id, err := a.sessions.AuthenticateSession(ctx, TokenHash(token))
if err != nil {
return model.User{}, err
}
return a.messenger.repo.GetUser(ctx, id)
}
func (a *Auth) Logout(ctx context.Context, token string) error {
return a.sessions.RevokeSession(ctx, TokenHash(token))
}
@@ -0,0 +1,98 @@
package usecase
import (
"context"
"backend/internal/domain/model"
"backend/internal/domain/repository"
"github.com/google/uuid"
)
const chatsCursorScope = "chats"
// Page — страница списка; NextCursor == nil, если следующей записи нет.
type Page[T any] struct {
Items []T
NextCursor *string
}
type Messenger struct {
repo repository.Repository
}
func NewMessenger(repo repository.Repository) *Messenger {
return &Messenger{repo: repo}
}
func (m *Messenger) CreateChat(ctx context.Context, caller uuid.UUID, title string, memberIDs []uuid.UUID) (model.Chat, error) {
draft, err := model.NewChatDraft(caller, title, memberIDs)
if err != nil {
return model.Chat{}, err
}
return m.repo.CreateChat(ctx, draft)
}
func (m *Messenger) ListChats(ctx context.Context, caller uuid.UUID, limit *int, cursor *string) (Page[model.Chat], error) {
q, err := model.NewPageQuery(limit, cursor, chatsCursorScope)
if err != nil {
return Page[model.Chat]{}, err
}
chats, more, err := m.repo.ListChats(ctx, caller, q)
if err != nil {
return Page[model.Chat]{}, err
}
return newPage(chats, more, chatsCursorScope, model.Chat.Position), nil
}
// GetChat отдаёт чат только участнику; постороннему — ErrNotFound, чтобы не
// раскрывать существование чужого чата.
func (m *Messenger) GetChat(ctx context.Context, caller, chatID uuid.UUID) (model.Chat, error) {
chat, err := m.repo.GetChat(ctx, chatID)
if err != nil {
return model.Chat{}, err
}
if !chat.HasMember(caller) {
return model.Chat{}, model.ErrNotFound
}
return chat, nil
}
// SendMessage сначала проверяет доступ, затем тело: посторонний получает 404
// даже на невалидное сообщение. Проверка членства и запись не атомарны, но
// участники чата неизменяемы, а чаты не удаляются, поэтому гонки здесь нет.
func (m *Messenger) SendMessage(ctx context.Context, caller, chatID uuid.UUID, text string) (model.Message, error) {
if _, err := m.GetChat(ctx, caller, chatID); err != nil {
return model.Message{}, err
}
draft, err := model.NewMessageDraft(chatID, caller, text)
if err != nil {
return model.Message{}, err
}
return m.repo.CreateMessage(ctx, draft)
}
func (m *Messenger) ListMessages(ctx context.Context, caller, chatID uuid.UUID, limit *int, cursor *string) (Page[model.Message], error) {
if _, err := m.GetChat(ctx, caller, chatID); err != nil {
return Page[model.Message]{}, err
}
scope := "messages:" + chatID.String()
q, err := model.NewPageQuery(limit, cursor, scope)
if err != nil {
return Page[model.Message]{}, err
}
messages, more, err := m.repo.ListMessages(ctx, chatID, q)
if err != nil {
return Page[model.Message]{}, err
}
return newPage(messages, more, scope, model.Message.Position), nil
}
func newPage[T any](items []T, more bool, scope string, position func(T) model.Position) Page[T] {
page := Page[T]{Items: items}
if more && len(items) > 0 {
next := model.EncodeCursor(scope, position(items[len(items)-1]))
page.NextCursor = &next
}
return page
}
+80
View File
@@ -0,0 +1,80 @@
package config
import (
"fmt"
"os"
"strings"
"time"
"github.com/spf13/viper"
)
// Config приходит только из окружения (12-factor): в контейнер не копируются
// ни .env, ни файлы конфигурации. Значения по умолчанию — ниже.
type Config struct {
Host string `mapstructure:"APP_HOST"`
Port int `mapstructure:"APP_PORT"`
Env string `mapstructure:"APP_ENV"`
LogLevel string `mapstructure:"LOG_LEVEL"`
ShutdownTimeout time.Duration `mapstructure:"SHUTDOWN_TIMEOUT"`
MaxBodyBytes int64 `mapstructure:"MAX_BODY_BYTES"`
MaxInflight int `mapstructure:"MAX_INFLIGHT"`
MaxQueue int `mapstructure:"MAX_QUEUE"`
QueueTimeout time.Duration `mapstructure:"QUEUE_TIMEOUT"`
DatabaseURLFile string `mapstructure:"DATABASE_URL_FILE"`
CacheURLFile string `mapstructure:"CACHE_URL_FILE"`
SessionTTLSeconds int `mapstructure:"SESSION_TTL_SECONDS"`
MaxConns int32 `mapstructure:"PG_MAX_CONNS"`
}
var defaults = map[string]any{
"APP_HOST": "0.0.0.0",
"APP_PORT": 8080,
"APP_ENV": "lab",
"LOG_LEVEL": "info",
"SHUTDOWN_TIMEOUT": "8s",
"MAX_BODY_BYTES": 64 << 10,
"MAX_INFLIGHT": 4,
"MAX_QUEUE": 32,
"QUEUE_TIMEOUT": "1s",
"DATABASE_URL_FILE": "/run/secrets/database_url",
"CACHE_URL_FILE": "/run/secrets/cache_url",
"SESSION_TTL_SECONDS": 3600,
"PG_MAX_CONNS": 8,
}
func Load() (Config, error) {
v := viper.New()
for key, value := range defaults {
v.SetDefault(key, value)
}
v.AutomaticEnv()
var cfg Config
if err := v.Unmarshal(&cfg); err != nil {
return Config{}, fmt.Errorf("parse config: %w", err)
}
if cfg.ShutdownTimeout <= 0 || cfg.ShutdownTimeout > 9*time.Second {
return Config{}, fmt.Errorf("SHUTDOWN_TIMEOUT must be in (0, 9s]: docker stop ждёт 10 с")
}
if cfg.SessionTTLSeconds < 1 || cfg.SessionTTLSeconds > 86400 {
return Config{}, fmt.Errorf("SESSION_TTL_SECONDS must be 1..86400")
}
if cfg.MaxConns<1||cfg.MaxConns>64{return Config{},fmt.Errorf("PG_MAX_CONNS must be 1..64")}
if cfg.MaxInflight<1||cfg.MaxInflight>4||cfg.MaxQueue<0||cfg.MaxQueue>128||cfg.QueueTimeout<=0||cfg.QueueTimeout>2*time.Second{return Config{},fmt.Errorf("HTTP gate exceeds the tested resource budget")}
if cfg.MaxBodyBytes<1||cfg.MaxBodyBytes>65536{return Config{},fmt.Errorf("MAX_BODY_BYTES must be 1..65536")}
return cfg, nil
}
func (c Config) Addr() string { return fmt.Sprintf("%s:%d", c.Host, c.Port) }
func ReadSecret(path string) (string, error) {
b, e := os.ReadFile(path)
if e != nil {
return "", fmt.Errorf("required secret file unavailable")
}
v := strings.TrimSpace(string(b))
if v == "" {
return "", fmt.Errorf("required secret is empty")
}
return v, nil
}
+6
View File
@@ -0,0 +1,6 @@
package config
import "testing"
func TestRejectsConfigurationOutsideResourceBudget(t *testing.T){
for _,tc:=range []struct{key,value string}{{"MAX_INFLIGHT","0"},{"MAX_INFLIGHT","5"},{"MAX_QUEUE","-1"},{"MAX_QUEUE","129"},{"QUEUE_TIMEOUT","0s"},{"QUEUE_TIMEOUT","3s"},{"MAX_BODY_BYTES","0"},{"MAX_BODY_BYTES","65537"},{"PG_MAX_CONNS","0"},{"PG_MAX_CONNS","65"},{"SESSION_TTL_SECONDS","0"},{"SESSION_TTL_SECONDS","86401"}}{t.Run(tc.key+tc.value,func(t *testing.T){t.Setenv(tc.key,tc.value);if _,e:=Load();e==nil{t.Fatal("accepted configuration beyond tested bounds")}})}
}
func TestPoolSizeIsConfigurableWithinBounds(t *testing.T){t.Setenv("PG_MAX_CONNS","1");cfg,e:=Load();if e!=nil{t.Fatal(e)};if cfg.MaxConns!=1{t.Fatal("configured pool size ignored")}}
+52
View File
@@ -0,0 +1,52 @@
package model
import (
"slices"
"time"
"github.com/google/uuid"
)
const maxChatMembers = 100
// Chat неизменяем после создания: участники задаются один раз, удаления в API нет.
type Chat struct {
ID uuid.UUID
Title string
MemberIDs []uuid.UUID
CreatedAt time.Time
}
func (c Chat) HasMember(userID uuid.UUID) bool {
return slices.Contains(c.MemberIDs, userID)
}
// ChatDraft — проверенные данные нового чата. Существование участников
// проверяет хранилище атомарно с созданием.
type ChatDraft struct {
Creator uuid.UUID
Title string
MemberIDs []uuid.UUID
}
func NewChatDraft(creator uuid.UUID, title string, memberIDs []uuid.UUID) (ChatDraft, error) {
if err := requireText("title", title, 1, 100); err != nil {
return ChatDraft{}, err
}
if len(memberIDs) == 0 || len(memberIDs) > maxChatMembers {
return ChatDraft{}, invalidf("member_ids: от 1 до %d участников", maxChatMembers)
}
seen := make(map[uuid.UUID]struct{}, len(memberIDs))
for _, id := range memberIDs {
if _, dup := seen[id]; dup {
return ChatDraft{}, invalidf("member_ids: повторяющийся участник")
}
seen[id] = struct{}{}
}
if _, ok := seen[creator]; !ok {
return ChatDraft{}, invalidf("member_ids: должен содержать создателя чата")
}
return ChatDraft{Creator: creator, Title: title, MemberIDs: slices.Clone(memberIDs)}, nil
}
func (c Chat) Position() Position { return Position{CreatedAt: c.CreatedAt, ID: c.ID} }
+32
View File
@@ -0,0 +1,32 @@
package model
import (
"errors"
"fmt"
)
var (
ErrUnavailable = errors.New("dependency unavailable")
ErrConflict = errors.New("conflict")
ErrNotFound = errors.New("not found")
ErrUnauthorized = errors.New("unauthorized")
ErrUsernameTaken = errors.New("username taken")
// ErrStorageFull — исчерпан бюджет памяти хранилища. Подтверждённые данные
// не вытесняются, поэтому новые записи отклоняются, а чтение продолжает работать.
ErrStorageFull = errors.New("storage full")
// ErrUnknownMember возвращает хранилище, если среди участников нового чата
// есть несуществующий пользователь; для клиента это ошибка ввода (400).
ErrUnknownMember error = &ValidationError{Message: "member_ids: неизвестный пользователь"}
)
// ValidationError — нарушение правил входных данных; Message безопасно
// показывать клиенту.
type ValidationError struct {
Message string
}
func (e *ValidationError) Error() string { return e.Message }
func invalidf(format string, args ...any) error {
return &ValidationError{Message: fmt.Sprintf(format, args...)}
}
+34
View File
@@ -0,0 +1,34 @@
package model
import (
"time"
"github.com/google/uuid"
)
const MaxMessageRunes = 4000
type Message struct {
ID uuid.UUID
ChatID uuid.UUID
SenderID uuid.UUID
Text string
CreatedAt time.Time
}
// MessageDraft — проверенное сообщение; отправитель берётся из идентификации,
// а не из тела запроса.
type MessageDraft struct {
ChatID uuid.UUID
SenderID uuid.UUID
Text string
}
func NewMessageDraft(chatID, senderID uuid.UUID, text string) (MessageDraft, error) {
if err := requireText("text", text, 1, MaxMessageRunes); err != nil {
return MessageDraft{}, err
}
return MessageDraft{ChatID: chatID, SenderID: senderID, Text: text}, nil
}
func (m Message) Position() Position { return Position{CreatedAt: m.CreatedAt, ID: m.ID} }
+126
View File
@@ -0,0 +1,126 @@
package model
import (
"errors"
"strings"
"testing"
"time"
"github.com/google/uuid"
)
func isValidationError(err error) bool {
var v *ValidationError
return errors.As(err, &v)
}
func TestNewUserDraft(t *testing.T) {
t.Parallel()
cases := []struct {
name, username, display string
ok bool
}{
{"minimal", "abc", "A", true},
{"max username 32", strings.Repeat("a", 32), "A", true},
{"username too short", "ab", "A", false},
{"username too long", strings.Repeat("a", 33), "A", false},
{"uppercase rejected", "Alice", "A", false},
{"cyrillic username rejected", "алиса", "A", false},
{"display 100 emoji ok", "abc", strings.Repeat("😀", 100), true},
{"display 101 code points rejected", "abc", strings.Repeat("ж", 101), false},
{"display whitespace only", "abc", " \t\n", false},
{"display empty", "abc", "", false},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
t.Parallel()
_, err := NewUserDraft(tc.username, tc.display)
if tc.ok && err != nil {
t.Fatalf("unexpected error: %v", err)
}
if !tc.ok && !isValidationError(err) {
t.Fatalf("want ValidationError, got %v", err)
}
})
}
}
func TestNewChatDraft(t *testing.T) {
t.Parallel()
me, other := uuid.New(), uuid.New()
tooMany := []uuid.UUID{me}
for range 100 {
tooMany = append(tooMany, uuid.New())
}
cases := []struct {
name string
members []uuid.UUID
ok bool
}{
{"creator only", []uuid.UUID{me}, true},
{"two members", []uuid.UUID{me, other}, true},
{"empty", nil, false},
{"creator missing", []uuid.UUID{other}, false},
{"duplicate member", []uuid.UUID{me, other, other}, false},
{"over 100 members", tooMany, false},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
t.Parallel()
_, err := NewChatDraft(me, "Чат", tc.members)
if tc.ok != (err == nil) {
t.Fatalf("ok=%v, err=%v", tc.ok, err)
}
})
}
}
func TestNewMessageDraftLimitsInCodePoints(t *testing.T) {
t.Parallel()
if _, err := NewMessageDraft(uuid.New(), uuid.New(), strings.Repeat("👋", MaxMessageRunes)); err != nil {
t.Fatalf("4000 four-byte code points must pass: %v", err)
}
if _, err := NewMessageDraft(uuid.New(), uuid.New(), strings.Repeat("a", MaxMessageRunes+1)); !isValidationError(err) {
t.Fatalf("4001 code points must be rejected, got %v", err)
}
}
func TestCursorRoundTripAndScope(t *testing.T) {
t.Parallel()
pos := Position{CreatedAt: time.Date(2026, 9, 1, 12, 0, 0, 123456000, time.UTC), ID: uuid.New()}
cursor := EncodeCursor("messages:a", pos)
q, err := NewPageQuery(nil, &cursor, "messages:a")
if err != nil || q.After == nil || *q.After != pos || q.Limit != DefaultPageLimit {
t.Fatalf("round trip failed: %+v, %v", q, err)
}
if _, err := NewPageQuery(nil, &cursor, "messages:b"); !isValidationError(err) {
t.Fatalf("cursor of another resource must be rejected, got %v", err)
}
for _, bad := range []string{"", "!!!", EncodeCursor("x", pos)[:5]} {
if _, err := NewPageQuery(nil, &bad, "messages:a"); !isValidationError(err) {
t.Fatalf("garbage cursor %q must be rejected, got %v", bad, err)
}
}
}
func TestPageLimitBounds(t *testing.T) {
t.Parallel()
for limit, ok := range map[int]bool{0: false, 1: true, 100: true, 101: false, -1: false} {
_, err := NewPageQuery(&limit, nil, "chats")
if ok != (err == nil) {
t.Errorf("limit=%d: ok=%v, err=%v", limit, ok, err)
}
}
}
func TestPositionOrderTiesBrokenByID(t *testing.T) {
t.Parallel()
at := time.Now()
low := Position{CreatedAt: at, ID: uuid.MustParse("00000000-0000-4000-8000-000000000001")}
high := Position{CreatedAt: at, ID: uuid.MustParse("ffffffff-0000-4000-8000-000000000000")}
later := Position{CreatedAt: at.Add(time.Microsecond), ID: low.ID}
if !high.After(low) || low.After(high) || !later.After(high) || low.After(low) {
t.Fatal("order must be (created_at, id) ascending")
}
}
+84
View File
@@ -0,0 +1,84 @@
package model
import (
"bytes"
"encoding/base64"
"strconv"
"strings"
"time"
"github.com/google/uuid"
)
const (
DefaultPageLimit = 50
MaxPageLimit = 100
)
// Position — ключ keyset-пагинации: история упорядочена по (created_at, id).
type Position struct {
CreatedAt time.Time
ID uuid.UUID
}
// After сообщает, стоит ли p строго после other в порядке (created_at, id).
func (p Position) After(other Position) bool {
if !p.CreatedAt.Equal(other.CreatedAt) {
return p.CreatedAt.After(other.CreatedAt)
}
return bytes.Compare(p.ID[:], other.ID[:]) > 0
}
// PageQuery — проверенный запрос страницы: limit 1–100 и позиция после
// последнего элемента предыдущей страницы (nil — с начала).
type PageQuery struct {
Limit int
After *Position
}
// NewPageQuery проверяет limit и курсор. scope привязывает курсор к ресурсу:
// курсор истории одного чата не подходит к другому чату или к списку чатов.
func NewPageQuery(limit *int, cursor *string, scope string) (PageQuery, error) {
q := PageQuery{Limit: DefaultPageLimit}
if limit != nil {
if *limit < 1 || *limit > MaxPageLimit {
return PageQuery{}, invalidf("limit: от 1 до %d", MaxPageLimit)
}
q.Limit = *limit
}
if cursor != nil {
pos, err := decodeCursor(*cursor, scope)
if err != nil {
return PageQuery{}, err
}
q.After = &pos
}
return q, nil
}
// EncodeCursor делает непрозрачную для клиента строку из позиции и scope.
func EncodeCursor(scope string, p Position) string {
raw := scope + "|" + strconv.FormatInt(p.CreatedAt.UnixMicro(), 10) + "|" + p.ID.String()
return base64.RawURLEncoding.EncodeToString([]byte(raw))
}
func decodeCursor(cursor, scope string) (Position, error) {
errBad := invalidf("cursor: некорректное значение")
raw, err := base64.RawURLEncoding.DecodeString(cursor)
if err != nil {
return Position{}, errBad
}
parts := strings.Split(string(raw), "|")
if len(parts) != 3 || parts[0] != scope {
return Position{}, errBad
}
micros, err := strconv.ParseInt(parts[1], 10, 64)
if err != nil {
return Position{}, errBad
}
id, err := uuid.Parse(parts[2])
if err != nil {
return Position{}, errBad
}
return Position{CreatedAt: time.UnixMicro(micros).UTC(), ID: id}, nil
}
@@ -0,0 +1,5 @@
package model
import "testing"
func TestRejectsNULInPersistedText(t *testing.T){
for _,field:=range []string{"display_name","title","text"}{t.Run(field,func(t *testing.T){if err:=requireText(field,"a\x00b",1,4000);err==nil{t.Fatal("PostgreSQL text must reject NUL as a validation error")}})}
}
+22
View File
@@ -0,0 +1,22 @@
package model
import (
"strings"
"unicode/utf8"
)
// requireText проверяет обязательную строку: длина в Unicode code points
// (не в байтах) и запрет строк только из пробельных символов.
func requireText(field, value string, minLen, maxLen int) error {
if strings.ContainsRune(value,0){return invalidf("%s: NUL недопустим в PostgreSQL text",field)}
if !utf8.ValidString(value) {
return invalidf("%s: некорректный UTF-8", field)
}
if strings.TrimSpace(value) == "" {
return invalidf("%s: пустая строка", field)
}
if n := utf8.RuneCountInString(value); n < minLen || n > maxLen {
return invalidf("%s: длина должна быть от %d до %d символов", field, minLen, maxLen)
}
return nil
}
+34
View File
@@ -0,0 +1,34 @@
package model
import (
"regexp"
"time"
"github.com/google/uuid"
)
var usernamePattern = regexp.MustCompile(`^[a-z0-9_]{3,32}$`)
type User struct {
ID uuid.UUID
Username string
DisplayName string
CreatedAt time.Time
}
// UserDraft — проверенные данные нового пользователя; ID и время назначает хранилище.
type UserDraft struct {
Username string
DisplayName string
PasswordHash string
}
func NewUserDraft(username, displayName string) (UserDraft, error) {
if !usernamePattern.MatchString(username) {
return UserDraft{}, invalidf("username: допустимо [a-z0-9_], от 3 до 32 символов")
}
if err := requireText("display_name", displayName, 1, 100); err != nil {
return UserDraft{}, err
}
return UserDraft{Username: username, DisplayName: displayName}, nil
}
+18
View File
@@ -0,0 +1,18 @@
package port
import (
"context"
"github.com/google/uuid"
"time"
)
type Passwords interface {
Hash(string) (string, error)
Verify(string, string) bool
}
type Sessions interface {
Credentials(context.Context, string) (uuid.UUID, string, error)
CreateSession(context.Context, string, uuid.UUID, time.Time) error
AuthenticateSession(context.Context, string) (uuid.UUID, error)
RevokeSession(context.Context, string) error
}
@@ -0,0 +1,49 @@
// Package repository — порт персистентности. В lab1 его реализует хранилище
// в памяти процесса, с lab2 — PostgreSQL; ядро от этой замены не меняется.
package repository
import (
"context"
"backend/internal/domain/model"
"backend/internal/domain/port"
"github.com/google/uuid"
)
// Repository assigns IDs and database timestamps. Keyset order is (created_at, id);
// concurrent commits do not provide insertion order or a traversal snapshot.
// Каждый метод атомарен сам по себе.
type Repository interface {
UserRepository
ChatRepository
MessageRepository
}
type Persistent interface {
Repository
port.Sessions
}
type UserRepository interface {
// CreateUser: model.ErrUsernameTaken, model.ErrStorageFull.
CreateUser(ctx context.Context, draft model.UserDraft) (model.User, error)
// GetUser: model.ErrNotFound.
GetUser(ctx context.Context, id uuid.UUID) (model.User, error)
}
type ChatRepository interface {
// CreateChat: model.ErrUnknownMember, model.ErrStorageFull.
CreateChat(ctx context.Context, draft model.ChatDraft) (model.Chat, error)
// GetChat: model.ErrNotFound.
GetChat(ctx context.Context, id uuid.UUID) (model.Chat, error)
// ListChats возвращает чаты участника и признак, что есть следующая страница.
ListChats(ctx context.Context, memberID uuid.UUID, q model.PageQuery) ([]model.Chat, bool, error)
}
type MessageRepository interface {
// CreateMessage: model.ErrNotFound (нет чата), model.ErrStorageFull.
CreateMessage(ctx context.Context, draft model.MessageDraft) (model.Message, error)
// ListMessages возвращает страницу истории и признак следующей страницы.
ListMessages(ctx context.Context, chatID uuid.UUID, q model.PageQuery) ([]model.Message, bool, error)
}
+18
View File
@@ -0,0 +1,18 @@
package logger
import (
"os"
"time"
"github.com/rs/zerolog"
)
// New — JSON-логи в stdout, их собирает docker logs.
func New(level string) zerolog.Logger {
lvl, err := zerolog.ParseLevel(level)
if err != nil || level == "" {
lvl = zerolog.InfoLevel
}
zerolog.TimeFieldFormat = time.RFC3339Nano
return zerolog.New(os.Stdout).Level(lvl).With().Timestamp().Logger()
}
+29
View File
@@ -0,0 +1,29 @@
package server
import (
"context"
"net/http"
"time"
)
type Server struct {
httpServer *http.Server
}
func New(addr string, handler http.Handler) *Server {
return &Server{httpServer: &http.Server{
Addr: addr,
Handler: handler,
ReadHeaderTimeout: 5 * time.Second,
ReadTimeout: 15 * time.Second,
WriteTimeout: 15 * time.Second,
IdleTimeout: 60 * time.Second,
MaxHeaderBytes: 16 << 10,
}}
}
func (s *Server) ListenAndServe() error { return s.httpServer.ListenAndServe() }
// Shutdown сразу закрывает слушающий сокет (новые соединения не принимаются)
// и ждёт завершения начатых запросов, но не дольше ctx.
func (s *Server) Shutdown(ctx context.Context) error { return s.httpServer.Shutdown(ctx) }