diff --git a/.dockerignore b/.dockerignore index 8a8cc9df..e607a046 100644 --- a/.dockerignore +++ b/.dockerignore @@ -20,5 +20,6 @@ evidence .DS_Store bin coverage.out +.cache coverage.out.tmp *.log diff --git a/.env.example b/.env.example index fa98c793..2cddf490 100644 --- a/.env.example +++ b/.env.example @@ -15,6 +15,7 @@ APP_ENV=dev SERVER_HOST=0.0.0.0 SERVER_PORT=8080 SERVER_READ_HEADER_TIMEOUT=10s +SERVER_READ_TIMEOUT=60s SERVER_SHUTDOWN_TIMEOUT=10s # Предел размера тела запроса (байт): защищает реплику от чтения огромного тела # до валидации. Для вложений LAB4 (до 10 MiB) значение нужно поднять. @@ -65,7 +66,7 @@ IDEMPOTENCY_TTL_SECONDS=86400 # budget, e.g. API_REPLICAS=4 API_CPU_LIMIT=0.25 API_MEM_LIMIT=192M. API_REPLICAS=2 API_CPU_LIMIT=0.50 -API_MEM_LIMIT=256M +API_MEM_LIMIT=384M # Connections of ONE API replica to PostgreSQL; the total is replicas × value. # Track 1 checks whether the shared connection budget becomes the saturation @@ -82,3 +83,24 @@ POSTGRES_MEM_LIMIT=384M # Loopback port of the HAProxy operator page (UP/DOWN of every replica). LB_STATS_PORT=8404 + +# --- Lab4: private S3 object store (SeaweedFS) ------------------------------- +# Synthetic local credentials. infra/s3/s3.json must contain the same values; +# scripts/check_s3_creds.py enforces that before the stand starts. +S3_ENDPOINT=http://localhost:8333 +S3_PUBLIC_ENDPOINT=http://127.0.0.1:8333 +S3_PORT=8333 +S3_REGION=us-east-1 +S3_BUCKET=messenger-attachments +S3_ACCESS_KEY_ID=lab4app +S3_SECRET_ACCESS_KEY=lab4app-secret +S3_ADMIN_ACCESS_KEY=lab4admin +S3_ADMIN_SECRET_ACCESS_KEY=lab4admin-secret + +# Attachment limits from contract 1.4.0. +MAX_UPLOAD_BYTES=10485760 +MAX_IMAGE_PIXELS=40000000 +# Presigned upload lifetime and the sweeper's safety window. +S3_PRESIGN_TTL=5m +S3_SWEEP_INTERVAL=1m +S3_SWEEP_GRACE=10m diff --git a/.github/workflows/app.yml b/.github/workflows/app.yml index fed44ada..89c3e684 100644 --- a/.github/workflows/app.yml +++ b/.github/workflows/app.yml @@ -47,7 +47,7 @@ jobs: tags: mtusi-messenger:ci stand: - name: Lab3 stand scenario + name: Lab4 stand scenario needs: build runs-on: ubuntu-latest timeout-minutes: 20 @@ -66,8 +66,14 @@ jobs: exit 1 - name: Public smoke through the LB run: make test + - name: Attachment negative scenarios + run: make test-attachments + - name: Presigned direct upload + run: make test-presign - name: Parallel idempotency through the LB run: python3 student-tests/idempotency_parallel.py --base-url http://localhost:8080 + - name: Upload, stop the serving replica, download through another + run: python3 student-tests/attachment_failover.py --base-url http://localhost:8080 - name: Stop one API replica and keep writing run: make test-failover ACTION_SCRIPT=scripts/stop-one.sh - name: Logs on failure diff --git a/.gitignore b/.gitignore index 35d6aca3..ad511f63 100644 --- a/.gitignore +++ b/.gitignore @@ -26,6 +26,7 @@ obj/ coverage/ coverage.out coverage.out.tmp +.cache/ *.log .DS_Store .idea/ diff --git a/.mockery.yml b/.mockery.yml index eecf98a8..629f91ef 100644 --- a/.mockery.yml +++ b/.mockery.yml @@ -27,6 +27,9 @@ packages: mtusi-messenger/internal/service/message: config: all: true + mtusi-messenger/internal/service/attachment: + config: + all: true mtusi-messenger/internal/service/session: config: all: true diff --git a/Dockerfile b/Dockerfile index b43fae52..b2de9f1c 100644 --- a/Dockerfile +++ b/Dockerfile @@ -19,11 +19,15 @@ WORKDIR /opt COPY go.mod go.sum ./ RUN go mod download -# The Go compiler spikes well above 1 GiB per package on large dependencies, so -# an unbounded parallel build OOMs small Docker VMs and CI runners. Cap -# parallelism; override with --build-arg GOFLAGS=-p=$(nproc) on a bigger host. -ARG GOFLAGS="-p=2" +# The Go compiler spikes well above 1 GiB per package on large dependencies +# (AWS SDK + pgx + Redis), so an unbounded or even -p=2 build OOMs Docker +# Desktop's default VM. Build one package at a time; override with +# --build-arg GOFLAGS=-p=$(nproc) on a bigger host. +ARG GOFLAGS="-p=1" ENV GOFLAGS=$GOFLAGS +# Keep the compiler well below Docker Desktop's default VM limit. +ENV GOGC=50 +ENV GOMEMLIMIT=1GiB COPY . . RUN CGO_ENABLED=0 GOOS=${TARGETOS} GOARCH=${TARGETARCH} \ @@ -33,7 +37,11 @@ RUN CGO_ENABLED=0 GOOS=${TARGETOS} GOARCH=${TARGETARCH} \ && CGO_ENABLED=0 GOOS=${TARGETOS} GOARCH=${TARGETARCH} \ go build -trimpath -buildvcs=false -tags timetzdata \ -ldflags="-s -w -X main.version=${VERSION}" \ - -o /out/migrate ./cmd/migrate + -o /out/migrate ./cmd/migrate \ + && CGO_ENABLED=0 GOOS=${TARGETOS} GOARCH=${TARGETARCH} \ + go build -trimpath -buildvcs=false -tags timetzdata \ + -ldflags="-s -w -X main.version=${VERSION}" \ + -o /out/s3init ./cmd/s3init FROM alpine:${ALPINE_VERSION} AS runtime RUN apk add --no-cache ca-certificates wget \ @@ -42,6 +50,7 @@ RUN apk add --no-cache ca-certificates wget \ COPY --from=build --chown=10001:10001 /out/messenger /usr/local/bin/messenger COPY --from=build --chown=10001:10001 /out/migrate /usr/local/bin/migrate +COPY --from=build --chown=10001:10001 /out/s3init /usr/local/bin/s3init COPY --chown=10001:10001 config/dev/config.yaml /etc/messenger/dev/config.yaml USER 10001:10001 diff --git a/Makefile b/Makefile index edc73ca9..4a3ff7c1 100644 --- a/Makefile +++ b/Makefile @@ -5,7 +5,7 @@ ACTION_SCRIPT ?= TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",) PYTHON_LOCAL = env -u HTTP_PROXY -u HTTPS_PROXY -u ALL_PROXY -u http_proxy -u https_proxy -u all_proxy NO_PROXY=localhost,127.0.0.1,::1 no_proxy=localhost,127.0.0.1,::1 $(PYTHON) -.PHONY: help check validate test load test-persistence test-failover smoke-local load-local test-idempotency test-lb-readiness up down ps logs +.PHONY: help check validate test test-attachments test-presign load test-persistence test-failover smoke-local load-local test-idempotency test-lb-readiness up down ps logs help: @echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes" @@ -13,6 +13,7 @@ help: check: $(PYTHON) scripts/check_contract.py + $(PYTHON) scripts/check_s3_creds.py validate: $(PYTHON) scripts/validate_openapi.py @@ -20,6 +21,12 @@ validate: test: $(PYTHON_LOCAL) tests/smoke.py --base-url "$(BASE_URL)" $(TLS_ARGS) +test-attachments: + $(PYTHON_LOCAL) student-tests/attachments_negative.py --base-url "$(BASE_URL)" $(TLS_ARGS) + +test-presign: + $(PYTHON_LOCAL) student-tests/presign_flow.py --base-url "$(BASE_URL)" $(TLS_ARGS) + load: $(PYTHON_LOCAL) tests/load.py --base-url "$(BASE_URL)" $(TLS_ARGS) @@ -116,7 +123,8 @@ generate: generate-api generate-mocks sqlc .PHONY: generate-api generate-api: - $(GO) tool ogen --config $(OGEN_CONFIG) --target $(OAS_DIR) --package oas --clean $(OPENAPI_SPEC) + $(GO) run ./tools/specgen + $(GO) tool ogen --config $(OGEN_CONFIG) --target $(OAS_DIR) --package oas --clean .cache/openapi.codegen.json .PHONY: generate-mocks generate-mocks: diff --git a/cmd/messenger/main.go b/cmd/messenger/main.go index 6179863a..841173ed 100644 --- a/cmd/messenger/main.go +++ b/cmd/messenger/main.go @@ -8,6 +8,7 @@ import ( "net/http" "os" "os/signal" + "sync" "syscall" "time" @@ -15,7 +16,9 @@ import ( "mtusi-messenger/internal/health" "mtusi-messenger/internal/logger" "mtusi-messenger/internal/platform/cache" + "mtusi-messenger/internal/platform/objectstore" "mtusi-messenger/internal/platform/token" + "mtusi-messenger/internal/service/attachment" "mtusi-messenger/internal/service/chat" "mtusi-messenger/internal/service/message" "mtusi-messenger/internal/service/session" @@ -57,6 +60,57 @@ func run(cfg config.Config, log *slog.Logger) error { defer store.Close() + objectStore, err := objectstore.New(objectstore.Config{ + Endpoint: cfg.S3.Endpoint, + PublicEndpoint: cfg.S3.PublicEndpoint, + Region: cfg.S3.Region, + Bucket: cfg.S3.Bucket, + AccessKeyID: cfg.S3.AccessKeyID, + SecretAccessKey: cfg.S3.SecretAccessKey, + UsePathStyle: cfg.S3.UsePathStyle, + Timeout: cfg.S3.Timeout, + }) + if err != nil { + return fmt.Errorf("connect object store: %w", err) + } + + attachmentRepository := store.Attachments() + attachmentService := attachment.NewService( + attachmentRepository, + objectStore, + attachment.Config{ + MaxUploadBytes: cfg.S3.MaxUploadBytes, + MaxImagePixels: cfg.S3.MaxImagePixels, + PresignTTL: cfg.S3.PresignTTL, + }, + log, + ) + + sweeper := attachment.NewSweeper( + attachmentRepository, + objectStore, + store, + cfg.S3.SweepGrace, + cfg.S3.SweepInterval, + log, + ) + + sweepCtx, stopSweeper := context.WithCancel(context.Background()) + var sweepWait sync.WaitGroup + + sweepWait.Add(1) + + go func() { + defer sweepWait.Done() + + sweeper.Run(sweepCtx) + }() + + defer func() { + stopSweeper() + sweepWait.Wait() + }() + redisCache, err := connectRedis(cfg.Redis) if err != nil { return err @@ -97,13 +151,16 @@ func run(cfg config.Config, log *slog.Logger) error { rest.NewHandler( user.NewService(store.Users()), chat.NewService(chatRepo), - message.NewService(store.Messages()), + message.NewService(store.Messages(), attachmentRepository), + attachmentService, health.New(pingers...), sessionService, ), rest.NewSecurityHandler(sessionService), + rest.NewExtensions(attachmentService, sessionService, log), log, cfg.Server.MaxBodyBytes, + cfg.S3.MaxUploadBytes, ) if err != nil { return fmt.Errorf("build router: %w", err) @@ -113,6 +170,7 @@ func run(cfg config.Config, log *slog.Logger) error { Addr: cfg.Addr(), Handler: router, ReadHeaderTimeout: cfg.Server.ReadHeaderTimeout, + ReadTimeout: cfg.Server.ReadTimeout, } errc := make(chan error, 1) diff --git a/cmd/s3init/main.go b/cmd/s3init/main.go new file mode 100644 index 00000000..fa4e947e --- /dev/null +++ b/cmd/s3init/main.go @@ -0,0 +1,223 @@ +// Command s3init bootstraps the private attachment bucket. It is idempotent: +// it runs before the API on every compose up, verifies the bucket and the +// application identity, and exits successfully when everything is in place. +package main + +import ( + "bytes" + "context" + "errors" + "fmt" + "log/slog" + "os" + "strings" + "time" + + "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/credentials" + "github.com/aws/aws-sdk-go-v2/service/s3" + "github.com/aws/smithy-go" + "github.com/google/uuid" +) + +const bootstrapTimeout = 120 * time.Second + +type settings struct { + Endpoint string + Region string + Bucket string + AdminAccessKey string + AdminSecretKey string + AppAccessKey string + AppSecretKey string +} + +func main() { + log := slog.New(slog.NewJSONHandler(os.Stdout, nil)) + + if err := run(log); err != nil { + log.Error("s3 bootstrap failed", slog.Any("error", err)) + os.Exit(1) + } +} + +func run(log *slog.Logger) error { + cfg, err := loadSettings() + if err != nil { + return err + } + + ctx, cancel := context.WithTimeout(context.Background(), bootstrapTimeout) + defer cancel() + + admin := newClient(cfg, cfg.AdminAccessKey, cfg.AdminSecretKey) + app := newClient(cfg, cfg.AppAccessKey, cfg.AppSecretKey) + + if err := waitForBucket(ctx, admin, cfg.Bucket); err != nil { + return err + } + + if err := probeAppIdentity(ctx, app, cfg.Bucket); err != nil { + return err + } + + if err := probeForbiddenPrefix(ctx, app, cfg.Bucket); err != nil { + return err + } + + log.Info("s3 bucket ready", + slog.String("endpoint", cfg.Endpoint), + slog.String("bucket", cfg.Bucket), + ) + + return nil +} + +func loadSettings() (settings, error) { + cfg := settings{ + Endpoint: strings.TrimSpace(os.Getenv("S3_ENDPOINT")), + Region: strings.TrimSpace(os.Getenv("S3_REGION")), + Bucket: strings.TrimSpace(os.Getenv("S3_BUCKET")), + AdminAccessKey: strings.TrimSpace(os.Getenv("S3_ADMIN_ACCESS_KEY")), + AdminSecretKey: strings.TrimSpace(os.Getenv("S3_ADMIN_SECRET_ACCESS_KEY")), + AppAccessKey: strings.TrimSpace(os.Getenv("S3_ACCESS_KEY_ID")), + AppSecretKey: strings.TrimSpace(os.Getenv("S3_SECRET_ACCESS_KEY")), + } + + switch { + case cfg.Endpoint == "": + return settings{}, errors.New("S3_ENDPOINT is required") + case cfg.Region == "": + return settings{}, errors.New("S3_REGION is required") + case cfg.Bucket == "": + return settings{}, errors.New("S3_BUCKET is required") + case cfg.AdminAccessKey == "" || cfg.AdminSecretKey == "": + return settings{}, errors.New("S3_ADMIN_ACCESS_KEY and S3_ADMIN_SECRET_ACCESS_KEY are required") + case cfg.AppAccessKey == "" || cfg.AppSecretKey == "": + return settings{}, errors.New("S3_ACCESS_KEY_ID and S3_SECRET_ACCESS_KEY are required") + } + + return cfg, nil +} + +func newClient(cfg settings, accessKey, secretKey string) *s3.Client { + return s3.New(s3.Options{ + Region: cfg.Region, + BaseEndpoint: aws.String(cfg.Endpoint), + UsePathStyle: true, + Credentials: credentials.NewStaticCredentialsProvider(accessKey, secretKey, ""), + }) +} + +func waitForBucket(ctx context.Context, client *s3.Client, bucket string) error { + for { + _, err := client.HeadBucket(ctx, &s3.HeadBucketInput{Bucket: aws.String(bucket)}) + if err == nil { + return nil + } + + if !isNotFound(err) { + return fmt.Errorf("head bucket: %w", err) + } + + if _, err := client.CreateBucket(ctx, &s3.CreateBucketInput{Bucket: aws.String(bucket)}); err == nil { + return nil + } else if isBucketExists(err) { + return nil + } else if !isNotFound(err) { + return fmt.Errorf("create bucket: %w", err) + } + + select { + case <-ctx.Done(): + return fmt.Errorf("wait for object store: %w", ctx.Err()) + case <-time.After(time.Second): + } + } +} + +func probeAppIdentity(ctx context.Context, client *s3.Client, bucket string) error { + key := "staging/.bootstrap/" + uuid.NewString() + + if _, err := client.PutObject(ctx, &s3.PutObjectInput{ + Bucket: aws.String(bucket), + Key: aws.String(key), + Body: bytes.NewReader([]byte("ok")), + ContentLength: aws.Int64(2), + ContentType: aws.String("text/plain"), + }); err != nil { + return fmt.Errorf("application identity cannot write: %w", err) + } + + defer func() { + _, _ = client.DeleteObject(ctx, &s3.DeleteObjectInput{ + Bucket: aws.String(bucket), + Key: aws.String(key), + }) + }() + + if _, err := client.HeadObject(ctx, &s3.HeadObjectInput{ + Bucket: aws.String(bucket), + Key: aws.String(key), + }); err != nil { + return fmt.Errorf("application identity cannot read: %w", err) + } + + if _, err := client.ListObjectsV2(ctx, &s3.ListObjectsV2Input{ + Bucket: aws.String(bucket), + Prefix: aws.String("staging/"), + }); err != nil { + return fmt.Errorf("application identity cannot list: %w", err) + } + + return nil +} + +func probeForbiddenPrefix(ctx context.Context, client *s3.Client, bucket string) error { + key := "forbidden/" + uuid.NewString() + + _, err := client.PutObject(ctx, &s3.PutObjectInput{ + Bucket: aws.String(bucket), + Key: aws.String(key), + Body: bytes.NewReader([]byte("must not be stored")), + }) + if err == nil { + _, _ = client.DeleteObject(ctx, &s3.DeleteObjectInput{ + Bucket: aws.String(bucket), + Key: aws.String(key), + }) + + return errors.New("application identity can write outside the allowed prefixes; check infra/s3/s3.json") + } + + var apiErr smithy.APIError + if !errors.As(err, &apiErr) || apiErr.ErrorCode() != "AccessDenied" { + return fmt.Errorf("forbidden-prefix probe returned an unexpected error: %w", err) + } + + return nil +} + +func isNotFound(err error) bool { + var apiErr smithy.APIError + if errors.As(err, &apiErr) { + switch apiErr.ErrorCode() { + case "NotFound", "NoSuchBucket", "NoSuchKey": + return true + } + } + + return false +} + +func isBucketExists(err error) bool { + var apiErr smithy.APIError + if errors.As(err, &apiErr) { + switch apiErr.ErrorCode() { + case "BucketAlreadyExists", "BucketAlreadyOwnedByYou": + return true + } + } + + return false +} diff --git a/compose.yaml b/compose.yaml index 03b59d92..93917d71 100644 --- a/compose.yaml +++ b/compose.yaml @@ -1,4 +1,4 @@ -# Lab3 stand: two API replicas behind a HAProxy load balancer. +# Lab4 stand: two API replicas behind HAProxy, PostgreSQL, Redis and SeaweedFS S3. # # cp -n .env.example .env # docker compose --env-file .env up -d --build @@ -8,13 +8,13 @@ # reachable from the host via `docker compose exec` / `docker compose logs`. # No container_name anywhere: replica hostnames stay the short container IDs, # which the application reports back as X-Instance-Id. -name: mtusi-messenger-lab3 +name: mtusi-messenger-lab4 +# The image is built once by the api service. migrate and s3-init only consume +# it; duplicating `build` here makes Compose compile the same Go tree in parallel +# and OOMs Docker Desktop's default VM. x-app: &app - build: - context: . - dockerfile: Dockerfile - image: mtusi-messenger:lab3 + image: mtusi-messenger:lab4 services: postgres: @@ -67,6 +67,54 @@ services: memory: 192M restart: unless-stopped + # Private S3-compatible object store. Only the S3 API is published, on + # loopback, so the presigned-upload track and evidence can reach it from the + # host. master/volume/filer ports stay inside the compose network. + seaweedfs: + image: chrislusf/seaweedfs:3.80@sha256:1055999e08eed1789b0ae45d235126e4495e23d3fb9d6396293fd42539b1ae6a + command: + - server + - -s3 + - -s3.config=/etc/seaweedfs/s3.json + - -dir=/data + - -master.volumeSizeLimitMB=64 + volumes: + - ./infra/s3/s3.json:/etc/seaweedfs/s3.json:ro + - seaweedfs-data:/data + ports: + - "127.0.0.1:${S3_PORT:-8333}:8333" + healthcheck: + test: ["CMD-SHELL", "wget -q -O /dev/null http://127.0.0.1:8333/healthz || exit 1"] + interval: 5s + timeout: 3s + retries: 20 + start_period: 60s + deploy: + resources: + limits: + cpus: "1.00" + memory: 768M + restart: unless-stopped + + # One-shot, idempotent bucket bootstrap and identity probe. + s3-init: + <<: *app + entrypoint: ["/usr/local/bin/s3init"] + environment: + S3_ENDPOINT: http://seaweedfs:8333 + S3_REGION: ${S3_REGION:-us-east-1} + S3_BUCKET: ${S3_BUCKET:-messenger-attachments} + S3_ADMIN_ACCESS_KEY: ${S3_ADMIN_ACCESS_KEY:-lab4admin} + S3_ADMIN_SECRET_ACCESS_KEY: ${S3_ADMIN_SECRET_ACCESS_KEY:-lab4admin-secret} + S3_ACCESS_KEY_ID: ${S3_ACCESS_KEY_ID:-lab4app} + S3_SECRET_ACCESS_KEY: ${S3_SECRET_ACCESS_KEY:-lab4app-secret} + depends_on: + seaweedfs: + condition: service_healthy + healthcheck: + disable: true + restart: "no" + # One-shot schema bootstrap; runs once to completion before any API replica. migrate: <<: *app @@ -95,6 +143,9 @@ services: api: <<: *app + build: + context: . + dockerfile: Dockerfile # Общий сетевой alias: LB резолвит одно имя в адреса всех реплик, поэтому # масштабирование и замена контейнеров не зависят от их номеров/ID. networks: @@ -117,6 +168,18 @@ services: REDIS_HOST: redis REDIS_PORT: "6379" CACHE_ENABLED: "true" + S3_ENDPOINT: http://seaweedfs:8333 + S3_PUBLIC_ENDPOINT: ${S3_PUBLIC_ENDPOINT:-http://127.0.0.1:8333} + S3_REGION: ${S3_REGION:-us-east-1} + S3_BUCKET: ${S3_BUCKET:-messenger-attachments} + S3_ACCESS_KEY_ID: ${S3_ACCESS_KEY_ID:-lab4app} + S3_SECRET_ACCESS_KEY: ${S3_SECRET_ACCESS_KEY:-lab4app-secret} + S3_USE_PATH_STYLE: "true" + S3_PRESIGN_TTL: ${S3_PRESIGN_TTL:-5m} + S3_SWEEP_INTERVAL: ${S3_SWEEP_INTERVAL:-1m} + S3_SWEEP_GRACE: ${S3_SWEEP_GRACE:-10m} + MAX_UPLOAD_BYTES: ${MAX_UPLOAD_BYTES:-10485760} + MAX_IMAGE_PIXELS: ${MAX_IMAGE_PIXELS:-40000000} # Размер пула соединений ОДНОЙ реплики; общий расход = реплики × значение. # Это один из общих ресурсов, который масштабирование расходует первым. POSTGRES_MAX_CONNS: "${POSTGRES_MAX_CONNS:-10}" @@ -125,7 +188,7 @@ services: resources: limits: cpus: "${API_CPU_LIMIT:-0.50}" - memory: ${API_MEM_LIMIT:-256M} + memory: ${API_MEM_LIMIT:-384M} # The app drains on SIGTERM within SERVER_SHUTDOWN_TIMEOUT; keep the grace # period above it so Docker does not SIGKILL an in-flight request. stop_grace_period: 15s @@ -136,6 +199,8 @@ services: condition: service_healthy migrate: condition: service_completed_successfully + s3-init: + condition: service_completed_successfully healthcheck: test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:8080/health/ready"] interval: 10s @@ -171,3 +236,4 @@ services: volumes: postgres18-data: redis7-data: + seaweedfs-data: diff --git a/docker-compose.local.yaml b/docker-compose.local.yaml index 0cdc50fc..0707f55b 100644 --- a/docker-compose.local.yaml +++ b/docker-compose.local.yaml @@ -1,10 +1,10 @@ -name: mtusi-messenger-lab2 +name: mtusi-messenger-lab4 x-app: &app build: context: . dockerfile: Dockerfile - image: mtusi-messenger:lab2 + image: mtusi-messenger:lab4 services: postgres: @@ -99,6 +99,6 @@ services: volumes: postgres18-data: - name: mtusi-messenger-lab2-postgres18-data + name: mtusi-messenger-lab4-postgres18-data redis7-data: - name: mtusi-messenger-lab2-redis7-data + name: mtusi-messenger-lab4-redis7-data diff --git a/go.mod b/go.mod index b627ea23..eba58d2f 100644 --- a/go.mod +++ b/go.mod @@ -3,6 +3,10 @@ module mtusi-messenger go 1.27.0 require ( + github.com/aws/aws-sdk-go-v2 v1.47.3 + github.com/aws/aws-sdk-go-v2/credentials v1.20.9 + github.com/aws/aws-sdk-go-v2/service/s3 v1.114.4 + github.com/aws/smithy-go v1.28.6 github.com/go-faster/errors v0.8.0 github.com/go-faster/jx v1.2.0 github.com/go-playground/validator/v10 v10.30.5 @@ -23,6 +27,14 @@ require ( cel.dev/expr v0.25.2 // indirect filippo.io/edwards25519 v1.2.0 // indirect github.com/antlr4-go/antlr/v4 v4.13.1 // indirect + github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.23 // indirect + github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.6 // indirect + github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.6 // indirect + github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.6 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.21 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.11.7 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.6 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.20.6 // indirect github.com/brunoga/deep v1.3.1 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect github.com/clipperhouse/uax29/v2 v2.2.0 // indirect diff --git a/go.sum b/go.sum index 850f17ae..2f490f36 100644 --- a/go.sum +++ b/go.sum @@ -5,6 +5,30 @@ filippo.io/edwards25519 v1.2.0/go.mod h1:xzAOLCNug/yB62zG1bQ8uziwrIqIuxhctzJT18Q github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= github.com/antlr4-go/antlr/v4 v4.13.1 h1:SqQKkuVZ+zWkMMNkjy5FZe5mr5WURWnlpmOuzYWrPrQ= github.com/antlr4-go/antlr/v4 v4.13.1/go.mod h1:GKmUxMtwp6ZgGwZSva4eWPC5mS6vUAmOABFgjdkM7Nw= +github.com/aws/aws-sdk-go-v2 v1.47.3 h1:HRoT/MkNi3bjO5xF4dCzLzvVmkvRGHj3/cLINDnJejk= +github.com/aws/aws-sdk-go-v2 v1.47.3/go.mod h1:xSl+OSI5ZUw6bSMupWc218zE5Pl+65MCCu3ySWFY99A= +github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.23 h1:/fGPpKrXTjzkhsDXExBgNT2cGwxiF9rLrQXh8RlXMhI= +github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.23/go.mod h1:QWUDuRi9PFjBHIU2iH1Pkldbe7zqLfXJC4wWLbF8nuQ= +github.com/aws/aws-sdk-go-v2/credentials v1.20.9 h1:SNO55PnWhaDafsOcv16lCA0kdoFMl/YlegWoVsU02s0= +github.com/aws/aws-sdk-go-v2/credentials v1.20.9/go.mod h1:+2reOTRtdD3VSBqpRDNwrZIYy8yMCYa7oK3WKTJ/I1I= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.6 h1:CqL8NN3p4I0JTwwV5MEoatIl4Y2amZ2X9dRD+0hbRL0= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.6/go.mod h1:exdJ32hMqXl0Wyo6NwqEC5yIhtua3+PDaKE8P29m4qE= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.6 h1:FpBq24TG6WVSObTNhQOv7Q0088rounUUlwn3zlNItkM= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.6/go.mod h1:ONzdPVYC95oBOu0VWNEsKEntcoemP3xVKjT+qWml1s4= +github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.6 h1:Qmn60RWuk9+bd2ddvJJqwf3Cpac3VvGMOdbGemtUhX4= +github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.6/go.mod h1:h/YJhe4AVyQxEUMluph10iqV7mjajH7A9L+BHF5ppis= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.21 h1:e6YW5uME30TkrElR+4/xcY7NB6CCj2dcv7vtmGXhfhQ= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.21/go.mod h1:obpHAMP693+f3/A8PkLhIqfK1C+NWWn8zXzqD3OH520= +github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.11.7 h1:CwvFlKw0uUScfgOMflXSRZa+ayXgOf6wk7lhyMemQYU= +github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.11.7/go.mod h1:4SbD8BB+p+QEnG0aX6DoWwrtk9SufyYXRsUv0nve8LE= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.6 h1:LHHdobjo5le1sjJdolitV7uVvYg3wkaeM1Ju2fDgeZQ= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.6/go.mod h1:CBGB0evAiaMD3Lk4wPO7LQCcCZLuhzL5Qf/wfEUHQ5w= +github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.20.6 h1:mYViDr2azcgxOpRrObZOl631bvavqILoE/L+Kxgbwys= +github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.20.6/go.mod h1:OXVdAo9jNhggB+hJRGOyy7WolGTKB6Rg7IIulDeSzPM= +github.com/aws/aws-sdk-go-v2/service/s3 v1.114.4 h1:MrkWRB58Qw5TEkb51QVooVLjlM3IevO2iVXEz74B8pg= +github.com/aws/aws-sdk-go-v2/service/s3 v1.114.4/go.mod h1:yfIxaKRHasvfy6tNEm3/LpqKsupMzQjMaWj9Y0jMVbo= +github.com/aws/smithy-go v1.28.6 h1:Pj+/sUviNYjow8ELRtNwKHZ9ECeF+7pATX3+shjLIrw= +github.com/aws/smithy-go v1.28.6/go.mod h1:YE2RhdIuDbA5E5bTdciG9KrW3+TiEONeUWCqxX9i1Fc= github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA= github.com/brunoga/deep v1.3.1 h1:bSrL6FhAZa6JlVv4vsi7Hg8SLwroDb1kgDERRVipBCo= github.com/brunoga/deep v1.3.1/go.mod h1:GDV6dnXqn80ezsLSZ5Wlv1PdKAWAO4L5PnKYtv2dgaI= diff --git a/infra/s3/README.md b/infra/s3/README.md new file mode 100644 index 00000000..c6c36598 --- /dev/null +++ b/infra/s3/README.md @@ -0,0 +1,25 @@ +# SeaweedFS identities + +`infra/s3/s3.json` is mounted read-only into the `seaweedfs` container and is +the single source of truth for S3 credentials and permissions. + +- `admin` is used only by the one-shot `s3-init` service (bucket creation and + probing). It is never given to the API. +- `app` is used by the API and by presigned uploads. It can read/write only + `messenger-attachments/attachments/*` and `messenger-attachments/staging/*`, + and list the bucket for the orphan sweeper. + +The credentials are synthetic values for the local stand. `.env.example` +carries the same values for the API and `scripts/check_s3_creds.py` fails the +offline check if they drift. Replace them in `.env` for any non-local run. + +Verify manually: + +```sh +# anonymous requests are denied +docker compose exec -T seaweedfs \ + wget -qO- http://127.0.0.1:8333/messenger-attachments/attachments/missing + +# the app identity cannot write outside its prefixes +docker compose run --rm s3-init # probes this and exits non-zero on violation +``` diff --git a/infra/s3/s3.json b/infra/s3/s3.json new file mode 100644 index 00000000..773f3bfc --- /dev/null +++ b/infra/s3/s3.json @@ -0,0 +1,24 @@ +{ + "identities": [ + { + "name": "admin", + "credentials": [ + {"accessKey": "lab4admin", "secretKey": "lab4admin-secret"} + ], + "actions": ["Admin", "Read", "Write", "List", "Tagging"] + }, + { + "name": "app", + "credentials": [ + {"accessKey": "lab4app", "secretKey": "lab4app-secret"} + ], + "actions": [ + "Read:messenger-attachments/attachments/*", + "Write:messenger-attachments/attachments/*", + "Read:messenger-attachments/staging/*", + "Write:messenger-attachments/staging/*", + "List:messenger-attachments" + ] + } + ] +} diff --git a/internal/config/config.go b/internal/config/config.go index e3729707..7b18ec54 100644 --- a/internal/config/config.go +++ b/internal/config/config.go @@ -36,6 +36,27 @@ type Config struct { Cache Cache `mapstructure:"cache"` Session Session `mapstructure:"session"` Idempotency Idempotency `mapstructure:"idempotency"` + S3 S3 `mapstructure:"s3"` +} + +// S3 describes the object store and attachment limits. Access keys are checked +// by the object-store constructor rather than the global validator: cmd/migrate +// and unit tests load this config without any S3 credentials. +type S3 struct { + Endpoint string `mapstructure:"endpoint" validate:"required,url"` + PublicEndpoint string `mapstructure:"public_endpoint" validate:"omitempty,url"` + Region string `mapstructure:"region" validate:"required"` + Bucket string `mapstructure:"bucket" validate:"required"` + AccessKeyID string `mapstructure:"access_key_id"` + SecretAccessKey string `mapstructure:"secret_access_key"` + UsePathStyle bool `mapstructure:"use_path_style"` + Timeout time.Duration `mapstructure:"timeout" validate:"required,gt=0"` + + MaxUploadBytes int64 `mapstructure:"max_upload_bytes" validate:"required,gt=0,lte=10485760"` + MaxImagePixels int64 `mapstructure:"max_image_pixels" validate:"required,gt=0,lte=40000000"` + PresignTTL time.Duration `mapstructure:"presign_ttl" validate:"required,gt=0"` + SweepInterval time.Duration `mapstructure:"sweep_interval" validate:"required,gt=0"` + SweepGrace time.Duration `mapstructure:"sweep_grace" validate:"required,gt=0"` } type Session struct { @@ -72,6 +93,7 @@ type Server struct { Host string `mapstructure:"host" validate:"required,hostname|ip"` Port int `mapstructure:"port" validate:"required,min=1,max=65535"` ReadHeaderTimeout time.Duration `mapstructure:"read_header_timeout" validate:"required,gt=0"` + ReadTimeout time.Duration `mapstructure:"read_timeout" validate:"required,gt=0"` ShutdownTimeout time.Duration `mapstructure:"shutdown_timeout" validate:"required,gt=0"` // MaxBodyBytes bounds a request body before the transport decodes it; uploads // of a later lab raise it explicitly (contract 4: 10 MiB attachments). @@ -123,8 +145,22 @@ var defaults = map[string]any{ "server.host": "0.0.0.0", "server.port": 8080, "server.read_header_timeout": "10s", + "server.read_timeout": "60s", "server.shutdown_timeout": "10s", "server.max_body_bytes": 262144, + "s3.endpoint": "http://localhost:8333", + "s3.public_endpoint": "http://localhost:8333", + "s3.region": "us-east-1", + "s3.bucket": "messenger-attachments", + "s3.access_key_id": "", + "s3.secret_access_key": "", + "s3.use_path_style": true, + "s3.timeout": "30s", + "s3.max_upload_bytes": 10485760, + "s3.max_image_pixels": 40000000, + "s3.presign_ttl": "5m", + "s3.sweep_interval": "1m", + "s3.sweep_grace": "10m", "log.level": "info", "log.format": "json", "session.ttl_seconds": 3600, @@ -161,6 +197,17 @@ func Load() (Config, error) { } } + // The skeleton suggests MAX_UPLOAD_BYTES / MAX_IMAGE_PIXELS. Keep those + // names while storing the values under the S3 section. + for key, env := range map[string]string{ + "s3.max_upload_bytes": "MAX_UPLOAD_BYTES", + "s3.max_image_pixels": "MAX_IMAGE_PIXELS", + } { + if err := v.BindEnv(key, env); err != nil { + return Config{}, fmt.Errorf("bind env %q: %w", env, err) + } + } + var cfg Config if err := v.Unmarshal(&cfg); err != nil { return Config{}, fmt.Errorf("unmarshal config: %w", err) diff --git a/internal/domain/attachment.go b/internal/domain/attachment.go new file mode 100644 index 00000000..9239141c --- /dev/null +++ b/internal/domain/attachment.go @@ -0,0 +1,90 @@ +package domain + +import ( + "time" + + "github.com/google/uuid" +) + +// AttachmentStatus is the lifecycle of an attachment. Only ready attachments +// are exposed to members; pending rows exist while the object is being written, +// failed rows are reserved for later labs. +type AttachmentStatus string + +const ( + AttachmentPending AttachmentStatus = "pending" + AttachmentReady AttachmentStatus = "ready" + AttachmentFailed AttachmentStatus = "failed" +) + +func (s AttachmentStatus) Valid() bool { + switch s { + case AttachmentPending, AttachmentReady, AttachmentFailed: + return true + default: + return false + } +} + +// Attachment describes the original object. ObjectKey is internal: it never +// leaves the service and must not be mapped into an API response. +type Attachment struct { + ID uuid.UUID + ChatID uuid.UUID + OwnerID uuid.UUID + Filename string + ContentType string + SizeBytes int64 + SHA256 string + Status AttachmentStatus + ErrorCode *string + ObjectKey string + CreatedAt time.Time + UpdatedAt time.Time +} + +// AttachmentDraft is a fully validated attachment awaiting persistence. +type AttachmentDraft struct { + ID uuid.UUID + ChatID uuid.UUID + OwnerID uuid.UUID + ObjectKey string + Filename string + ContentType string + SizeBytes int64 + SHA256 string +} + +// AttachmentState is the minimal projection used while validating message +// attachments in a transaction. +type AttachmentState struct { + ID uuid.UUID + Status AttachmentStatus +} + +// AttachmentKey is the minimal projection used by the orphan sweeper. +type AttachmentKey struct { + ID uuid.UUID + ObjectKey string + Status AttachmentStatus + CreatedAt time.Time +} + +// PresignRequest is the validated client intent for a direct upload. +type PresignRequest struct { + ChatID uuid.UUID + OwnerID uuid.UUID + Filename string + ContentType string + SizeBytes int64 + SHA256 string +} + +// PresignResult is returned by the server and never contains credentials. +type PresignResult struct { + AttachmentID uuid.UUID + UploadURL string + ExpiresAt time.Time + SizeBytes int64 + SHA256 string +} diff --git a/internal/domain/errors.go b/internal/domain/errors.go index a8314c69..9844b441 100644 --- a/internal/domain/errors.go +++ b/internal/domain/errors.go @@ -3,13 +3,16 @@ package domain import "errors" var ( - ErrNotFound = errors.New("not found") - ErrUsernameTaken = errors.New("username already taken") - ErrUnknownMember = errors.New("member does not exist") - ErrValidation = errors.New("validation failed") - ErrInvalidCursor = errors.New("invalid cursor") - ErrConflict = errors.New("conflict") - ErrIdempotency = errors.New("idempotency key already used with another payload") - ErrUnauthenticated = errors.New("unauthenticated") - ErrUnavailable = errors.New("temporarily unavailable") + ErrNotFound = errors.New("not found") + ErrUsernameTaken = errors.New("username already taken") + ErrUnknownMember = errors.New("member does not exist") + ErrValidation = errors.New("validation failed") + ErrInvalidCursor = errors.New("invalid cursor") + ErrConflict = errors.New("conflict") + ErrIdempotency = errors.New("idempotency key already used with another payload") + ErrUnauthenticated = errors.New("unauthenticated") + ErrUnavailable = errors.New("temporarily unavailable") + ErrTooLarge = errors.New("payload is too large") + ErrUnsupportedMedia = errors.New("unsupported media type") + ErrIncomplete = errors.New("object is not fully uploaded") ) diff --git a/internal/domain/message.go b/internal/domain/message.go index 1ac8fba6..9820c38f 100644 --- a/internal/domain/message.go +++ b/internal/domain/message.go @@ -3,17 +3,22 @@ package domain import ( "crypto/sha256" "fmt" + "strings" "time" "github.com/google/uuid" ) +// MaxMessageAttachments is the contract limit for attachment_ids on a message. +const MaxMessageAttachments = 10 + type Message struct { - ID uuid.UUID - ChatID uuid.UUID - SenderID uuid.UUID - Text string - CreatedAt time.Time + ID uuid.UUID + ChatID uuid.UUID + SenderID uuid.UUID + Text string + AttachmentIDs []uuid.UUID + CreatedAt time.Time } // MessageIdempotency is the client Idempotency-Key together with the fingerprint @@ -25,15 +30,36 @@ type MessageIdempotency struct { } type MessageDraft struct { - ChatID uuid.UUID - SenderID uuid.UUID - Text string - Idempotency MessageIdempotency + ChatID uuid.UUID + SenderID uuid.UUID + Text string + AttachmentIDs []uuid.UUID + Idempotency MessageIdempotency } +// Validate enforces the contract rule that a message carries either non-blank +// text or at least one attachment, never neither. func (d MessageDraft) Validate() error { - if err := validateNotBlank("text", d.Text); err != nil { - return err + if strings.TrimSpace(d.Text) == "" && len(d.AttachmentIDs) == 0 { + return fmt.Errorf("message has neither text nor attachments: %w", ErrValidation) + } + + if len(d.AttachmentIDs) > MaxMessageAttachments { + return fmt.Errorf("too many attachments: %w", ErrValidation) + } + + seen := make(map[uuid.UUID]struct{}, len(d.AttachmentIDs)) + + for _, id := range d.AttachmentIDs { + if id == uuid.Nil { + return fmt.Errorf("attachment id is empty: %w", ErrValidation) + } + + if _, ok := seen[id]; ok { + return fmt.Errorf("duplicate attachment id %s: %w", id, ErrValidation) + } + + seen[id] = struct{}{} } if d.Idempotency.Key == "" { diff --git a/internal/imagecheck/imagecheck.go b/internal/imagecheck/imagecheck.go new file mode 100644 index 00000000..3349c904 --- /dev/null +++ b/internal/imagecheck/imagecheck.go @@ -0,0 +1,365 @@ +// Package imagecheck validates PNG and JPEG structure without decoding the +// raster. A full decode of a 40-megapixel image would allocate hundreds of +// megabytes; attachment uploads must stay bounded. The parser verifies chunk +// CRCs and the JPEG marker/scan structure, which catches truncation and +// corruption while using constant memory. +package imagecheck + +import ( + "bufio" + "encoding/binary" + "errors" + "fmt" + "hash/crc32" + "io" + "os" +) + +var ( + ErrUnsupported = errors.New("unsupported image format") + ErrCorrupt = errors.New("corrupt image") + ErrTooLarge = errors.New("image has too many pixels") +) + +const ( + pngSignature = "\x89PNG\r\n\x1a\n" + maxChunkSize = 1 << 30 +) + +// Info is the validated header. ContentType is one of image/png or image/jpeg. +type Info struct { + ContentType string + Width int64 + Height int64 +} + +func ValidateFile(path string, maxPixels int64) (Info, error) { + file, err := os.Open(path) + if err != nil { + return Info{}, fmt.Errorf("open upload: %w", err) + } + defer func() { _ = file.Close() }() + + return Validate(file, maxPixels) +} + +// Validate consumes the reader to EOF (so a caller hashing the stream gets all +// bytes) and returns the detected format and dimensions. +func Validate(r io.Reader, maxPixels int64) (Info, error) { + reader := bufio.NewReaderSize(r, 64<<10) + + header, err := reader.Peek(8) + if err != nil { + if errors.Is(err, io.EOF) || errors.Is(err, io.ErrUnexpectedEOF) { + return Info{}, fmt.Errorf("%w: image is empty or truncated", ErrUnsupported) + } + + return Info{}, err + } + + switch { + case string(header[:8]) == pngSignature: + return validatePNG(reader, maxPixels) + case header[0] == 0xFF && header[1] == 0xD8 && header[2] == 0xFF: + return validateJPEG(reader, maxPixels) + default: + return Info{}, fmt.Errorf("%w: unrecognised signature", ErrUnsupported) + } +} + +func validatePNG(reader *bufio.Reader, maxPixels int64) (Info, error) { + if _, err := reader.Discard(len(pngSignature)); err != nil { + return Info{}, corrupt("png signature", err) + } + + var ( + info Info + seen = make(map[string]bool, 4) + first = true + hasIDAT bool + ) + + info.ContentType = "image/png" + + for { + var lengthBytes [4]byte + if _, err := io.ReadFull(reader, lengthBytes[:]); err != nil { + return Info{}, corrupt("png chunk length", err) + } + + length := int64(binary.BigEndian.Uint32(lengthBytes[:])) + if length < 0 || length > maxChunkSize { + return Info{}, corruptf("png chunk length %d", length) + } + + var typeBytes [4]byte + if _, err := io.ReadFull(reader, typeBytes[:]); err != nil { + return Info{}, corrupt("png chunk type", err) + } + + chunkType := string(typeBytes[:]) + checksum := crc32.NewIEEE() + _, _ = checksum.Write(typeBytes[:]) + + if first && chunkType != "IHDR" { + return Info{}, corruptf("png first chunk is %q, want IHDR", chunkType) + } + + first = false + + if err := checkCriticalChunk(chunkType, seen); err != nil { + return Info{}, err + } + + data, err := readChunkData(reader, checksum, length) + if err != nil { + return Info{}, corrupt("png chunk data", err) + } + + var crcBytes [4]byte + if _, err := io.ReadFull(reader, crcBytes[:]); err != nil { + return Info{}, corrupt("png chunk crc", err) + } + + if binary.BigEndian.Uint32(crcBytes[:]) != checksum.Sum32() { + return Info{}, corruptf("png chunk %q crc mismatch", chunkType) + } + + switch chunkType { + case "IHDR": + if length != 13 { + return Info{}, corruptf("png IHDR length %d", length) + } + + info.Width = int64(binary.BigEndian.Uint32(data[0:4])) + info.Height = int64(binary.BigEndian.Uint32(data[4:8])) + + if info.Width <= 0 || info.Height <= 0 { + return Info{}, corruptf("png dimensions %dx%d", info.Width, info.Height) + } + + // Short-circuit before multiplying: a malicious IHDR can contain + // 32-bit dimensions whose product overflows int64. + if maxPixels > 0 && (info.Width > maxPixels || info.Height > maxPixels || info.Width*info.Height > maxPixels) { + return Info{}, fmt.Errorf("%w: %dx%d", ErrTooLarge, info.Width, info.Height) + } + case "IDAT": + hasIDAT = true + case "IEND": + if length != 0 { + return Info{}, corruptf("png IEND length %d", length) + } + + if !hasIDAT { + return Info{}, corruptf("png has no IDAT chunk") + } + + if _, err := io.Copy(io.Discard, reader); err != nil { + return Info{}, corrupt("png trailing data", err) + } + + return info, nil + } + } +} + +func checkCriticalChunk(chunkType string, seen map[string]bool) error { + if chunkType == "IHDR" || chunkType == "PLTE" || chunkType == "IDAT" || chunkType == "IEND" { + seen[chunkType] = true + return nil + } + + if chunkType[0] >= 'A' && chunkType[0] <= 'Z' { + return corruptf("png unknown critical chunk %q", chunkType) + } + + return nil +} + +func readChunkData(reader io.Reader, checksum io.Writer, length int64) ([]byte, error) { + if length <= 64<<10 { + data := make([]byte, length) + if _, err := io.ReadFull(reader, data); err != nil { + return nil, err + } + + _, _ = checksum.Write(data) + + return data, nil + } + + if _, err := io.CopyN(checksum, reader, length); err != nil { + return nil, err + } + + return nil, nil +} + +func validateJPEG(reader *bufio.Reader, maxPixels int64) (Info, error) { + if _, err := reader.Discard(2); err != nil { + return Info{}, corrupt("jpeg SOI", err) + } + + var ( + info Info + hasSOF bool + hasSOS bool + pending byte + markerErr error + ) + + info.ContentType = "image/jpeg" + + for { + marker := pending + pending = 0 + + if marker == 0 { + marker, markerErr = nextMarker(reader) + if markerErr != nil { + return Info{}, corrupt("jpeg marker", markerErr) + } + } + + switch { + case marker == 0xD9: // EOI + if !hasSOF || !hasSOS { + return Info{}, corruptf("jpeg missing SOF or SOS") + } + + if _, err := io.Copy(io.Discard, reader); err != nil { + return Info{}, corrupt("jpeg trailing data", err) + } + + return info, nil + case isStandalone(marker): + continue + } + + length, err := readUint16(reader) + if err != nil { + return Info{}, corrupt("jpeg segment length", err) + } + + if length < 2 { + return Info{}, corruptf("jpeg segment %02x length %d", marker, length) + } + + data := make([]byte, int(length)-2) + if _, err := io.ReadFull(reader, data); err != nil { + return Info{}, corrupt("jpeg segment data", err) + } + + switch { + case isSOF(marker): + if len(data) < 5 { + return Info{}, corruptf("jpeg SOF %02x is too short", marker) + } + + info.Height = int64(binary.BigEndian.Uint16(data[1:3])) + info.Width = int64(binary.BigEndian.Uint16(data[3:5])) + + if info.Width <= 0 || info.Height <= 0 { + return Info{}, corruptf("jpeg dimensions %dx%d", info.Width, info.Height) + } + + hasSOF = true + + if maxPixels > 0 && info.Width*info.Height > maxPixels { + return Info{}, fmt.Errorf("%w: %dx%d", ErrTooLarge, info.Width, info.Height) + } + case marker == 0xDA: // SOS + hasSOS = true + + next, err := scanEntropy(reader) + if err != nil { + return Info{}, corrupt("jpeg scan", err) + } + + pending = next + } + } +} + +func nextMarker(reader *bufio.Reader) (byte, error) { + for { + value, err := reader.ReadByte() + if err != nil { + return 0, err + } + + if value != 0xFF { + return 0, fmt.Errorf("unexpected byte %02x before marker", value) + } + + value, err = reader.ReadByte() + if err != nil { + return 0, err + } + + if value == 0xFF { + continue + } + + return value, nil + } +} + +// scanEntropy consumes entropy-coded data after SOS and returns the next +// non-RST marker (0xFF prefix consumed). +func scanEntropy(reader *bufio.Reader) (byte, error) { + for { + value, err := reader.ReadByte() + if err != nil { + return 0, err + } + + if value != 0xFF { + continue + } + + value, err = reader.ReadByte() + if err != nil { + return 0, err + } + + switch { + case value == 0x00: + continue + case value >= 0xD0 && value <= 0xD7: + continue + default: + return value, nil + } + } +} + +func readUint16(reader io.Reader) (uint16, error) { + var raw [2]byte + if _, err := io.ReadFull(reader, raw[:]); err != nil { + return 0, err + } + + return binary.BigEndian.Uint16(raw[:]), nil +} + +func isSOF(marker byte) bool { + switch marker { + case 0xC0, 0xC1, 0xC2, 0xC3, 0xC5, 0xC6, 0xC7, 0xC9, 0xCA, 0xCB, 0xCD, 0xCE, 0xCF: + return true + default: + return false + } +} + +func isStandalone(marker byte) bool { + return marker == 0x01 || (marker >= 0xD0 && marker <= 0xD7) +} + +func corrupt(context string, err error) error { + return fmt.Errorf("%w: %s: %w", ErrCorrupt, context, err) +} + +func corruptf(format string, args ...any) error { + return fmt.Errorf("%w: %s", ErrCorrupt, fmt.Sprintf(format, args...)) +} diff --git a/internal/imagecheck/imagecheck_test.go b/internal/imagecheck/imagecheck_test.go new file mode 100644 index 00000000..b859ef6f --- /dev/null +++ b/internal/imagecheck/imagecheck_test.go @@ -0,0 +1,110 @@ +package imagecheck_test + +import ( + "bytes" + "image" + "image/color" + "image/jpeg" + "image/png" + "testing" + + "github.com/stretchr/testify/require" + + "mtusi-messenger/internal/imagecheck" +) + +func encodePNG(t *testing.T, width, height int) []byte { + t.Helper() + + source := image.NewRGBA(image.Rect(0, 0, width, height)) + for x := range width { + for y := range height { + source.Set(x, y, color.RGBA{R: uint8(x), G: uint8(y), B: 128, A: 255}) + } + } + + var buffer bytes.Buffer + require.NoError(t, png.Encode(&buffer, source)) + + return buffer.Bytes() +} + +func encodeJPEG(t *testing.T, width, height int) []byte { + t.Helper() + + source := image.NewRGBA(image.Rect(0, 0, width, height)) + for x := range width { + for y := range height { + source.Set(x, y, color.RGBA{R: uint8(x), G: uint8(y), B: 64, A: 255}) + } + } + + var buffer bytes.Buffer + require.NoError(t, jpeg.Encode(&buffer, source, &jpeg.Options{Quality: 90})) + + return buffer.Bytes() +} + +func TestValidatePNG(t *testing.T) { + info, err := imagecheck.Validate(bytes.NewReader(encodePNG(t, 32, 20)), 40_000_000) + require.NoError(t, err) + require.Equal(t, "image/png", info.ContentType) + require.Equal(t, int64(32), info.Width) + require.Equal(t, int64(20), info.Height) +} + +func TestValidateJPEG(t *testing.T) { + info, err := imagecheck.Validate(bytes.NewReader(encodeJPEG(t, 24, 16)), 40_000_000) + require.NoError(t, err) + require.Equal(t, "image/jpeg", info.ContentType) + require.Equal(t, int64(24), info.Width) + require.Equal(t, int64(16), info.Height) +} + +func TestValidateRejectsUnsupported(t *testing.T) { + _, err := imagecheck.Validate(bytes.NewReader([]byte("not an image at all")), 40_000_000) + require.ErrorIs(t, err, imagecheck.ErrUnsupported) + + _, err = imagecheck.Validate(bytes.NewReader(nil), 40_000_000) + require.ErrorIs(t, err, imagecheck.ErrUnsupported) +} + +func TestValidateRejectsTruncatedPNG(t *testing.T) { + data := encodePNG(t, 64, 64) + _, err := imagecheck.Validate(bytes.NewReader(data[:len(data)/2]), 40_000_000) + require.ErrorIs(t, err, imagecheck.ErrCorrupt) +} + +func TestValidateRejectsPNGCRCMismatch(t *testing.T) { + data := encodePNG(t, 64, 64) + index := bytes.Index(data, []byte("IDAT")) + require.Positive(t, index) + data[index+8] ^= 0xFF // first IDAT payload byte; CRC no longer matches + + _, err := imagecheck.Validate(bytes.NewReader(data), 40_000_000) + require.ErrorIs(t, err, imagecheck.ErrCorrupt) +} + +func TestValidateRejectsTruncatedJPEG(t *testing.T) { + data := encodeJPEG(t, 64, 64) + _, err := imagecheck.Validate(bytes.NewReader(data[:len(data)-32]), 40_000_000) + require.ErrorIs(t, err, imagecheck.ErrCorrupt) +} + +func TestValidateRejectsTooManyPixels(t *testing.T) { + _, err := imagecheck.Validate(bytes.NewReader(encodePNG(t, 100, 100)), 9_999) + require.ErrorIs(t, err, imagecheck.ErrTooLarge) + + _, err = imagecheck.Validate(bytes.NewReader(encodeJPEG(t, 100, 100)), 9_999) + require.ErrorIs(t, err, imagecheck.ErrTooLarge) +} + +func TestValidateAllowsTrailingBytes(t *testing.T) { + pngData := append(encodePNG(t, 8, 8), []byte("trailing")...) + _, err := imagecheck.Validate(bytes.NewReader(pngData), 40_000_000) + require.NoError(t, err) + + jpegData := append(encodeJPEG(t, 8, 8), []byte("trailing")...) + _, err = imagecheck.Validate(bytes.NewReader(jpegData), 40_000_000) + require.NoError(t, err) +} diff --git a/internal/platform/objectstore/objectstore.go b/internal/platform/objectstore/objectstore.go new file mode 100644 index 00000000..a45f9b81 --- /dev/null +++ b/internal/platform/objectstore/objectstore.go @@ -0,0 +1,32 @@ +// Package objectstore defines the S3-compatible port used by attachments. +// Metadata never belongs here: PostgreSQL is the source of truth, this package +// only moves bytes and exposes object timestamps for the orphan sweeper. +package objectstore + +import ( + "context" + "io" + "time" +) + +// Object is the provider-neutral view of one stored object. +type Object struct { + Key string + Size int64 + ContentType string + LastModified time.Time + Metadata map[string]string +} + +// Store is implemented by S3-compatible backends. Put requires a seekable body +// because AWS SigV4 may need to rewind the payload; the proxy upload path always +// passes an *os.File. +type Store interface { + Put(ctx context.Context, key string, body io.ReadSeeker, size int64, contentType string, metadata map[string]string) error + Open(ctx context.Context, key string) (io.ReadCloser, Object, error) + Head(ctx context.Context, key string) (Object, error) + Copy(ctx context.Context, src, dst, contentType string, metadata map[string]string) error + Delete(ctx context.Context, key string) error + List(ctx context.Context, prefix string) ([]Object, error) + PresignPut(ctx context.Context, key string, ttl time.Duration) (string, time.Time, error) +} diff --git a/internal/platform/objectstore/s3.go b/internal/platform/objectstore/s3.go new file mode 100644 index 00000000..6b288180 --- /dev/null +++ b/internal/platform/objectstore/s3.go @@ -0,0 +1,287 @@ +package objectstore + +import ( + "context" + "errors" + "fmt" + "io" + "net" + "net/http" + "strings" + "time" + + "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/credentials" + "github.com/aws/aws-sdk-go-v2/service/s3" + "github.com/aws/aws-sdk-go-v2/service/s3/types" + "github.com/aws/smithy-go" + + "mtusi-messenger/internal/domain" +) + +// Config is the S3 connection subset. Limits belong to the attachment service. +type Config struct { + Endpoint string + PublicEndpoint string + Region string + Bucket string + AccessKeyID string + SecretAccessKey string + UsePathStyle bool + Timeout time.Duration +} + +// S3 is an object store backed by an S3-compatible server (SeaweedFS in the +// lab stand, MinIO/AWS in other deployments). +type S3 struct { + bucket string + internal *s3.Client + public *s3.Client + timeout time.Duration +} + +var _ Store = (*S3)(nil) + +func New(cfg Config) (*S3, error) { + if cfg.Endpoint == "" || cfg.Region == "" || cfg.Bucket == "" { + return nil, errors.New("object store: endpoint, region and bucket are required") + } + + if cfg.AccessKeyID == "" || cfg.SecretAccessKey == "" { + return nil, errors.New("object store: access key id and secret access key are required") + } + + if cfg.PublicEndpoint == "" { + cfg.PublicEndpoint = cfg.Endpoint + } + + httpClient := &http.Client{ + Transport: &http.Transport{ + Proxy: http.ProxyFromEnvironment, + DialContext: (&net.Dialer{ + Timeout: 3 * time.Second, + KeepAlive: 30 * time.Second, + }).DialContext, + TLSHandshakeTimeout: 3 * time.Second, + ResponseHeaderTimeout: 15 * time.Second, + MaxIdleConnsPerHost: 16, + IdleConnTimeout: 90 * time.Second, + }, + // Downloads stream through the response body; an overall client + // timeout would abort them. + } + + newClient := func(endpoint string) *s3.Client { + return s3.New(s3.Options{ + Region: cfg.Region, + BaseEndpoint: aws.String(endpoint), + UsePathStyle: cfg.UsePathStyle, + Credentials: credentials.NewStaticCredentialsProvider(cfg.AccessKeyID, cfg.SecretAccessKey, ""), + HTTPClient: httpClient, + }) + } + + st := &S3{ + bucket: cfg.Bucket, + internal: newClient(cfg.Endpoint), + public: newClient(cfg.PublicEndpoint), + timeout: cfg.Timeout, + } + + return st, nil +} + +func (s *S3) Put( + ctx context.Context, + key string, + body io.ReadSeeker, + size int64, + contentType string, + metadata map[string]string, +) error { + ctx, cancel := s.operationContext(ctx) + defer cancel() + + _, err := s.internal.PutObject(ctx, &s3.PutObjectInput{ + Bucket: aws.String(s.bucket), + Key: aws.String(key), + Body: body, + ContentLength: aws.Int64(size), + ContentType: aws.String(contentType), + Metadata: metadata, + }) + if err != nil { + return mapObjectError("put object", key, err) + } + + return nil +} + +func (s *S3) Open(ctx context.Context, key string) (io.ReadCloser, Object, error) { + output, err := s.internal.GetObject(ctx, &s3.GetObjectInput{ + Bucket: aws.String(s.bucket), + Key: aws.String(key), + }) + if err != nil { + return nil, Object{}, mapObjectError("open object", key, err) + } + + object := Object{ + Key: key, + Size: aws.ToInt64(output.ContentLength), + ContentType: aws.ToString(output.ContentType), + LastModified: aws.ToTime(output.LastModified), + Metadata: output.Metadata, + } + + return output.Body, object, nil +} + +func (s *S3) Head(ctx context.Context, key string) (Object, error) { + output, err := s.internal.HeadObject(ctx, &s3.HeadObjectInput{ + Bucket: aws.String(s.bucket), + Key: aws.String(key), + }) + if err != nil { + return Object{}, mapObjectError("head object", key, err) + } + + return Object{ + Key: key, + Size: aws.ToInt64(output.ContentLength), + ContentType: aws.ToString(output.ContentType), + LastModified: aws.ToTime(output.LastModified), + Metadata: output.Metadata, + }, nil +} + +func (s *S3) Copy(ctx context.Context, src, dst, contentType string, metadata map[string]string) error { + ctx, cancel := s.operationContext(ctx) + defer cancel() + + _, err := s.internal.CopyObject(ctx, &s3.CopyObjectInput{ + Bucket: aws.String(s.bucket), + Key: aws.String(dst), + CopySource: aws.String(s.bucket + "/" + src), + MetadataDirective: types.MetadataDirectiveReplace, + ContentType: aws.String(contentType), + Metadata: metadata, + }) + if err != nil { + return mapObjectError("copy object", src+" -> "+dst, err) + } + + return nil +} + +func (s *S3) Delete(ctx context.Context, key string) error { + ctx, cancel := s.operationContext(ctx) + defer cancel() + + _, err := s.internal.DeleteObject(ctx, &s3.DeleteObjectInput{ + Bucket: aws.String(s.bucket), + Key: aws.String(key), + }) + if err != nil { + return mapObjectError("delete object", key, err) + } + + return nil +} + +func (s *S3) List(ctx context.Context, prefix string) ([]Object, error) { + ctx, cancel := s.operationContext(ctx) + defer cancel() + + var ( + objects []Object + token *string + ) + + for { + output, err := s.internal.ListObjectsV2(ctx, &s3.ListObjectsV2Input{ + Bucket: aws.String(s.bucket), + Prefix: aws.String(prefix), + ContinuationToken: token, + }) + if err != nil { + return nil, mapObjectError("list objects", prefix, err) + } + + for _, item := range output.Contents { + objects = append(objects, Object{ + Key: aws.ToString(item.Key), + Size: aws.ToInt64(item.Size), + LastModified: aws.ToTime(item.LastModified), + }) + } + + if !aws.ToBool(output.IsTruncated) { + break + } + + token = output.NextContinuationToken + if token == nil || *token == "" { + break + } + } + + return objects, nil +} + +// PresignPut signs only the bucket, key and host. Deliberately no Content-Type +// or checksum: adding them to the signed headers forces every client to send +// exactly those headers, and SeaweedFS does not validate checksums anyway. +// Completion verifies the actual bytes instead. +func (s *S3) PresignPut( + ctx context.Context, + key string, + ttl time.Duration, +) (string, time.Time, error) { + expiresAt := time.Now().UTC().Add(ttl) + + presigned, err := s3.NewPresignClient(s.public).PresignPutObject( + ctx, + &s3.PutObjectInput{ + Bucket: aws.String(s.bucket), + Key: aws.String(key), + }, + func(options *s3.PresignOptions) { + options.Expires = ttl + }, + ) + if err != nil { + return "", time.Time{}, mapObjectError("presign put", key, err) + } + + return presigned.URL, expiresAt, nil +} + +func (s *S3) operationContext(ctx context.Context) (context.Context, context.CancelFunc) { + if s.timeout <= 0 { + return context.WithCancel(ctx) + } + + return context.WithTimeout(ctx, s.timeout) +} + +func mapObjectError(operation, subject string, err error) error { + var apiErr smithy.APIError + + if errors.As(err, &apiErr) { + switch apiErr.ErrorCode() { + case "NotFound", "NoSuchKey", "NoSuchBucket": + return fmt.Errorf("%s %q: %w", operation, subject, domain.ErrNotFound) + } + } + + if errors.Is(err, context.Canceled) { + return fmt.Errorf("%s %q: %w", operation, subject, err) + } + + if strings.Contains(strings.ToLower(err.Error()), "no such key") { + return fmt.Errorf("%s %q: %w", operation, subject, domain.ErrNotFound) + } + + return fmt.Errorf("%w: %s %q: %w", domain.ErrUnavailable, operation, subject, err) +} diff --git a/internal/service/attachment/mocks/LockStore.go b/internal/service/attachment/mocks/LockStore.go new file mode 100644 index 00000000..52155f3f --- /dev/null +++ b/internal/service/attachment/mocks/LockStore.go @@ -0,0 +1,115 @@ +// Code generated by mockery; DO NOT EDIT. +// github.com/vektra/mockery +// template: testify + +package mocks + +import ( + "context" + + mock "github.com/stretchr/testify/mock" +) + +// NewMockLockStore creates a new instance of MockLockStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockLockStore(t interface { + mock.TestingT + Cleanup(func()) +}) *MockLockStore { + if helper, ok := t.(interface{ Helper() }); ok { + helper.Helper() + } + + mock := &MockLockStore{} + mock.Mock.Test(t) + + t.Cleanup(func() { + if helper, ok := t.(interface{ Helper() }); ok { + helper.Helper() + } + mock.AssertExpectations(t) + }) + + return mock +} + +// MockLockStore is an autogenerated mock type for the LockStore type +type MockLockStore struct { + mock.Mock +} + +type MockLockStore_Expecter struct { + mock *mock.Mock +} + +func (_m *MockLockStore) EXPECT() *MockLockStore_Expecter { + return &MockLockStore_Expecter{mock: &_m.Mock} +} + +// AcquireSweepLock provides a mock function for the type MockLockStore +func (_mock *MockLockStore) AcquireSweepLock(ctx context.Context) (func(), bool, error) { + ret := _mock.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for AcquireSweepLock") + } + + var r0 func() + var r1 bool + var r2 error + if returnFunc, ok := ret.Get(0).(func(context.Context) (func(), bool, error)); ok { + return returnFunc(ctx) + } + if returnFunc, ok := ret.Get(0).(func(context.Context) func()); ok { + r0 = returnFunc(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(func()) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context) bool); ok { + r1 = returnFunc(ctx) + } else { + r1 = ret.Get(1).(bool) + } + if returnFunc, ok := ret.Get(2).(func(context.Context) error); ok { + r2 = returnFunc(ctx) + } else { + r2 = ret.Error(2) + } + return r0, r1, r2 +} + +// MockLockStore_AcquireSweepLock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AcquireSweepLock' +type MockLockStore_AcquireSweepLock_Call struct { + *mock.Call +} + +// AcquireSweepLock is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockLockStore_Expecter) AcquireSweepLock(ctx any) *MockLockStore_AcquireSweepLock_Call { + return &MockLockStore_AcquireSweepLock_Call{Call: _e.mock.On("AcquireSweepLock", ctx)} +} + +func (_c *MockLockStore_AcquireSweepLock_Call) Run(run func(ctx context.Context)) *MockLockStore_AcquireSweepLock_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *MockLockStore_AcquireSweepLock_Call) Return(release func(), acquired bool, err error) *MockLockStore_AcquireSweepLock_Call { + _c.Call.Return(release, acquired, err) + return _c +} + +func (_c *MockLockStore_AcquireSweepLock_Call) RunAndReturn(run func(ctx context.Context) (func(), bool, error)) *MockLockStore_AcquireSweepLock_Call { + _c.Call.Return(run) + return _c +} diff --git a/internal/service/attachment/mocks/Repository.go b/internal/service/attachment/mocks/Repository.go new file mode 100644 index 00000000..ac27f08d --- /dev/null +++ b/internal/service/attachment/mocks/Repository.go @@ -0,0 +1,683 @@ +// Code generated by mockery; DO NOT EDIT. +// github.com/vektra/mockery +// template: testify + +package mocks + +import ( + "context" + "mtusi-messenger/internal/domain" + "time" + + "github.com/google/uuid" + mock "github.com/stretchr/testify/mock" +) + +// NewMockRepository creates a new instance of MockRepository. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockRepository(t interface { + mock.TestingT + Cleanup(func()) +}) *MockRepository { + if helper, ok := t.(interface{ Helper() }); ok { + helper.Helper() + } + + mock := &MockRepository{} + mock.Mock.Test(t) + + t.Cleanup(func() { + if helper, ok := t.(interface{ Helper() }); ok { + helper.Helper() + } + mock.AssertExpectations(t) + }) + + return mock +} + +// MockRepository is an autogenerated mock type for the Repository type +type MockRepository struct { + mock.Mock +} + +type MockRepository_Expecter struct { + mock *mock.Mock +} + +func (_m *MockRepository) EXPECT() *MockRepository_Expecter { + return &MockRepository_Expecter{mock: &_m.Mock} +} + +// Create provides a mock function for the type MockRepository +func (_mock *MockRepository) Create(ctx context.Context, draft domain.AttachmentDraft) (domain.Attachment, error) { + ret := _mock.Called(ctx, draft) + + if len(ret) == 0 { + panic("no return value specified for Create") + } + + var r0 domain.Attachment + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, domain.AttachmentDraft) (domain.Attachment, error)); ok { + return returnFunc(ctx, draft) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, domain.AttachmentDraft) domain.Attachment); ok { + r0 = returnFunc(ctx, draft) + } else { + r0 = ret.Get(0).(domain.Attachment) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, domain.AttachmentDraft) error); ok { + r1 = returnFunc(ctx, draft) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockRepository_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create' +type MockRepository_Create_Call struct { + *mock.Call +} + +// Create is a helper method to define mock.On call +// - ctx context.Context +// - draft domain.AttachmentDraft +func (_e *MockRepository_Expecter) Create(ctx any, draft any) *MockRepository_Create_Call { + return &MockRepository_Create_Call{Call: _e.mock.On("Create", ctx, draft)} +} + +func (_c *MockRepository_Create_Call) Run(run func(ctx context.Context, draft domain.AttachmentDraft)) *MockRepository_Create_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 domain.AttachmentDraft + if args[1] != nil { + arg1 = args[1].(domain.AttachmentDraft) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockRepository_Create_Call) Return(attachment domain.Attachment, err error) *MockRepository_Create_Call { + _c.Call.Return(attachment, err) + return _c +} + +func (_c *MockRepository_Create_Call) RunAndReturn(run func(ctx context.Context, draft domain.AttachmentDraft) (domain.Attachment, error)) *MockRepository_Create_Call { + _c.Call.Return(run) + return _c +} + +// DeletePending provides a mock function for the type MockRepository +func (_mock *MockRepository) DeletePending(ctx context.Context, id uuid.UUID) error { + ret := _mock.Called(ctx, id) + + if len(ret) == 0 { + panic("no return value specified for DeletePending") + } + + var r0 error + if returnFunc, ok := ret.Get(0).(func(context.Context, uuid.UUID) error); ok { + r0 = returnFunc(ctx, id) + } else { + r0 = ret.Error(0) + } + return r0 +} + +// MockRepository_DeletePending_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeletePending' +type MockRepository_DeletePending_Call struct { + *mock.Call +} + +// DeletePending is a helper method to define mock.On call +// - ctx context.Context +// - id uuid.UUID +func (_e *MockRepository_Expecter) DeletePending(ctx any, id any) *MockRepository_DeletePending_Call { + return &MockRepository_DeletePending_Call{Call: _e.mock.On("DeletePending", ctx, id)} +} + +func (_c *MockRepository_DeletePending_Call) Run(run func(ctx context.Context, id uuid.UUID)) *MockRepository_DeletePending_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 uuid.UUID + if args[1] != nil { + arg1 = args[1].(uuid.UUID) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockRepository_DeletePending_Call) Return(err error) *MockRepository_DeletePending_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockRepository_DeletePending_Call) RunAndReturn(run func(ctx context.Context, id uuid.UUID) error) *MockRepository_DeletePending_Call { + _c.Call.Return(run) + return _c +} + +// GetForMember provides a mock function for the type MockRepository +func (_mock *MockRepository) GetForMember(ctx context.Context, userID uuid.UUID, id uuid.UUID) (domain.Attachment, error) { + ret := _mock.Called(ctx, userID, id) + + if len(ret) == 0 { + panic("no return value specified for GetForMember") + } + + var r0 domain.Attachment + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, uuid.UUID, uuid.UUID) (domain.Attachment, error)); ok { + return returnFunc(ctx, userID, id) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, uuid.UUID, uuid.UUID) domain.Attachment); ok { + r0 = returnFunc(ctx, userID, id) + } else { + r0 = ret.Get(0).(domain.Attachment) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, uuid.UUID, uuid.UUID) error); ok { + r1 = returnFunc(ctx, userID, id) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockRepository_GetForMember_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetForMember' +type MockRepository_GetForMember_Call struct { + *mock.Call +} + +// GetForMember is a helper method to define mock.On call +// - ctx context.Context +// - userID uuid.UUID +// - id uuid.UUID +func (_e *MockRepository_Expecter) GetForMember(ctx any, userID any, id any) *MockRepository_GetForMember_Call { + return &MockRepository_GetForMember_Call{Call: _e.mock.On("GetForMember", ctx, userID, id)} +} + +func (_c *MockRepository_GetForMember_Call) Run(run func(ctx context.Context, userID uuid.UUID, id uuid.UUID)) *MockRepository_GetForMember_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 uuid.UUID + if args[1] != nil { + arg1 = args[1].(uuid.UUID) + } + var arg2 uuid.UUID + if args[2] != nil { + arg2 = args[2].(uuid.UUID) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *MockRepository_GetForMember_Call) Return(attachment domain.Attachment, err error) *MockRepository_GetForMember_Call { + _c.Call.Return(attachment, err) + return _c +} + +func (_c *MockRepository_GetForMember_Call) RunAndReturn(run func(ctx context.Context, userID uuid.UUID, id uuid.UUID) (domain.Attachment, error)) *MockRepository_GetForMember_Call { + _c.Call.Return(run) + return _c +} + +// GetForOwner provides a mock function for the type MockRepository +func (_mock *MockRepository) GetForOwner(ctx context.Context, ownerID uuid.UUID, id uuid.UUID) (domain.Attachment, error) { + ret := _mock.Called(ctx, ownerID, id) + + if len(ret) == 0 { + panic("no return value specified for GetForOwner") + } + + var r0 domain.Attachment + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, uuid.UUID, uuid.UUID) (domain.Attachment, error)); ok { + return returnFunc(ctx, ownerID, id) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, uuid.UUID, uuid.UUID) domain.Attachment); ok { + r0 = returnFunc(ctx, ownerID, id) + } else { + r0 = ret.Get(0).(domain.Attachment) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, uuid.UUID, uuid.UUID) error); ok { + r1 = returnFunc(ctx, ownerID, id) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockRepository_GetForOwner_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetForOwner' +type MockRepository_GetForOwner_Call struct { + *mock.Call +} + +// GetForOwner is a helper method to define mock.On call +// - ctx context.Context +// - ownerID uuid.UUID +// - id uuid.UUID +func (_e *MockRepository_Expecter) GetForOwner(ctx any, ownerID any, id any) *MockRepository_GetForOwner_Call { + return &MockRepository_GetForOwner_Call{Call: _e.mock.On("GetForOwner", ctx, ownerID, id)} +} + +func (_c *MockRepository_GetForOwner_Call) Run(run func(ctx context.Context, ownerID uuid.UUID, id uuid.UUID)) *MockRepository_GetForOwner_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 uuid.UUID + if args[1] != nil { + arg1 = args[1].(uuid.UUID) + } + var arg2 uuid.UUID + if args[2] != nil { + arg2 = args[2].(uuid.UUID) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *MockRepository_GetForOwner_Call) Return(attachment domain.Attachment, err error) *MockRepository_GetForOwner_Call { + _c.Call.Return(attachment, err) + return _c +} + +func (_c *MockRepository_GetForOwner_Call) RunAndReturn(run func(ctx context.Context, ownerID uuid.UUID, id uuid.UUID) (domain.Attachment, error)) *MockRepository_GetForOwner_Call { + _c.Call.Return(run) + return _c +} + +// IsChatMember provides a mock function for the type MockRepository +func (_mock *MockRepository) IsChatMember(ctx context.Context, chatID uuid.UUID, userID uuid.UUID) (bool, error) { + ret := _mock.Called(ctx, chatID, userID) + + if len(ret) == 0 { + panic("no return value specified for IsChatMember") + } + + var r0 bool + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, uuid.UUID, uuid.UUID) (bool, error)); ok { + return returnFunc(ctx, chatID, userID) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, uuid.UUID, uuid.UUID) bool); ok { + r0 = returnFunc(ctx, chatID, userID) + } else { + r0 = ret.Get(0).(bool) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, uuid.UUID, uuid.UUID) error); ok { + r1 = returnFunc(ctx, chatID, userID) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockRepository_IsChatMember_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsChatMember' +type MockRepository_IsChatMember_Call struct { + *mock.Call +} + +// IsChatMember is a helper method to define mock.On call +// - ctx context.Context +// - chatID uuid.UUID +// - userID uuid.UUID +func (_e *MockRepository_Expecter) IsChatMember(ctx any, chatID any, userID any) *MockRepository_IsChatMember_Call { + return &MockRepository_IsChatMember_Call{Call: _e.mock.On("IsChatMember", ctx, chatID, userID)} +} + +func (_c *MockRepository_IsChatMember_Call) Run(run func(ctx context.Context, chatID uuid.UUID, userID uuid.UUID)) *MockRepository_IsChatMember_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 uuid.UUID + if args[1] != nil { + arg1 = args[1].(uuid.UUID) + } + var arg2 uuid.UUID + if args[2] != nil { + arg2 = args[2].(uuid.UUID) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *MockRepository_IsChatMember_Call) Return(b bool, err error) *MockRepository_IsChatMember_Call { + _c.Call.Return(b, err) + return _c +} + +func (_c *MockRepository_IsChatMember_Call) RunAndReturn(run func(ctx context.Context, chatID uuid.UUID, userID uuid.UUID) (bool, error)) *MockRepository_IsChatMember_Call { + _c.Call.Return(run) + return _c +} + +// ListKeys provides a mock function for the type MockRepository +func (_mock *MockRepository) ListKeys(ctx context.Context, limit int32, offset int32) ([]domain.AttachmentKey, error) { + ret := _mock.Called(ctx, limit, offset) + + if len(ret) == 0 { + panic("no return value specified for ListKeys") + } + + var r0 []domain.AttachmentKey + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, int32, int32) ([]domain.AttachmentKey, error)); ok { + return returnFunc(ctx, limit, offset) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, int32, int32) []domain.AttachmentKey); ok { + r0 = returnFunc(ctx, limit, offset) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]domain.AttachmentKey) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, int32, int32) error); ok { + r1 = returnFunc(ctx, limit, offset) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockRepository_ListKeys_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListKeys' +type MockRepository_ListKeys_Call struct { + *mock.Call +} + +// ListKeys is a helper method to define mock.On call +// - ctx context.Context +// - limit int32 +// - offset int32 +func (_e *MockRepository_Expecter) ListKeys(ctx any, limit any, offset any) *MockRepository_ListKeys_Call { + return &MockRepository_ListKeys_Call{Call: _e.mock.On("ListKeys", ctx, limit, offset)} +} + +func (_c *MockRepository_ListKeys_Call) Run(run func(ctx context.Context, limit int32, offset int32)) *MockRepository_ListKeys_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 int32 + if args[1] != nil { + arg1 = args[1].(int32) + } + var arg2 int32 + if args[2] != nil { + arg2 = args[2].(int32) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *MockRepository_ListKeys_Call) Return(attachmentKeys []domain.AttachmentKey, err error) *MockRepository_ListKeys_Call { + _c.Call.Return(attachmentKeys, err) + return _c +} + +func (_c *MockRepository_ListKeys_Call) RunAndReturn(run func(ctx context.Context, limit int32, offset int32) ([]domain.AttachmentKey, error)) *MockRepository_ListKeys_Call { + _c.Call.Return(run) + return _c +} + +// ListStalePending provides a mock function for the type MockRepository +func (_mock *MockRepository) ListStalePending(ctx context.Context, createdBefore time.Time, limit int32) ([]domain.Attachment, error) { + ret := _mock.Called(ctx, createdBefore, limit) + + if len(ret) == 0 { + panic("no return value specified for ListStalePending") + } + + var r0 []domain.Attachment + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, time.Time, int32) ([]domain.Attachment, error)); ok { + return returnFunc(ctx, createdBefore, limit) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, time.Time, int32) []domain.Attachment); ok { + r0 = returnFunc(ctx, createdBefore, limit) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]domain.Attachment) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, time.Time, int32) error); ok { + r1 = returnFunc(ctx, createdBefore, limit) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockRepository_ListStalePending_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListStalePending' +type MockRepository_ListStalePending_Call struct { + *mock.Call +} + +// ListStalePending is a helper method to define mock.On call +// - ctx context.Context +// - createdBefore time.Time +// - limit int32 +func (_e *MockRepository_Expecter) ListStalePending(ctx any, createdBefore any, limit any) *MockRepository_ListStalePending_Call { + return &MockRepository_ListStalePending_Call{Call: _e.mock.On("ListStalePending", ctx, createdBefore, limit)} +} + +func (_c *MockRepository_ListStalePending_Call) Run(run func(ctx context.Context, createdBefore time.Time, limit int32)) *MockRepository_ListStalePending_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 time.Time + if args[1] != nil { + arg1 = args[1].(time.Time) + } + var arg2 int32 + if args[2] != nil { + arg2 = args[2].(int32) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *MockRepository_ListStalePending_Call) Return(attachments []domain.Attachment, err error) *MockRepository_ListStalePending_Call { + _c.Call.Return(attachments, err) + return _c +} + +func (_c *MockRepository_ListStalePending_Call) RunAndReturn(run func(ctx context.Context, createdBefore time.Time, limit int32) ([]domain.Attachment, error)) *MockRepository_ListStalePending_Call { + _c.Call.Return(run) + return _c +} + +// ListStates provides a mock function for the type MockRepository +func (_mock *MockRepository) ListStates(ctx context.Context, chatID uuid.UUID, ids []uuid.UUID) ([]domain.AttachmentState, error) { + ret := _mock.Called(ctx, chatID, ids) + + if len(ret) == 0 { + panic("no return value specified for ListStates") + } + + var r0 []domain.AttachmentState + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, uuid.UUID, []uuid.UUID) ([]domain.AttachmentState, error)); ok { + return returnFunc(ctx, chatID, ids) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, uuid.UUID, []uuid.UUID) []domain.AttachmentState); ok { + r0 = returnFunc(ctx, chatID, ids) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]domain.AttachmentState) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, uuid.UUID, []uuid.UUID) error); ok { + r1 = returnFunc(ctx, chatID, ids) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockRepository_ListStates_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListStates' +type MockRepository_ListStates_Call struct { + *mock.Call +} + +// ListStates is a helper method to define mock.On call +// - ctx context.Context +// - chatID uuid.UUID +// - ids []uuid.UUID +func (_e *MockRepository_Expecter) ListStates(ctx any, chatID any, ids any) *MockRepository_ListStates_Call { + return &MockRepository_ListStates_Call{Call: _e.mock.On("ListStates", ctx, chatID, ids)} +} + +func (_c *MockRepository_ListStates_Call) Run(run func(ctx context.Context, chatID uuid.UUID, ids []uuid.UUID)) *MockRepository_ListStates_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 uuid.UUID + if args[1] != nil { + arg1 = args[1].(uuid.UUID) + } + var arg2 []uuid.UUID + if args[2] != nil { + arg2 = args[2].([]uuid.UUID) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *MockRepository_ListStates_Call) Return(attachmentStates []domain.AttachmentState, err error) *MockRepository_ListStates_Call { + _c.Call.Return(attachmentStates, err) + return _c +} + +func (_c *MockRepository_ListStates_Call) RunAndReturn(run func(ctx context.Context, chatID uuid.UUID, ids []uuid.UUID) ([]domain.AttachmentState, error)) *MockRepository_ListStates_Call { + _c.Call.Return(run) + return _c +} + +// MarkReady provides a mock function for the type MockRepository +func (_mock *MockRepository) MarkReady(ctx context.Context, id uuid.UUID, objectKey string) (domain.Attachment, error) { + ret := _mock.Called(ctx, id, objectKey) + + if len(ret) == 0 { + panic("no return value specified for MarkReady") + } + + var r0 domain.Attachment + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, uuid.UUID, string) (domain.Attachment, error)); ok { + return returnFunc(ctx, id, objectKey) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, uuid.UUID, string) domain.Attachment); ok { + r0 = returnFunc(ctx, id, objectKey) + } else { + r0 = ret.Get(0).(domain.Attachment) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, uuid.UUID, string) error); ok { + r1 = returnFunc(ctx, id, objectKey) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockRepository_MarkReady_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MarkReady' +type MockRepository_MarkReady_Call struct { + *mock.Call +} + +// MarkReady is a helper method to define mock.On call +// - ctx context.Context +// - id uuid.UUID +// - objectKey string +func (_e *MockRepository_Expecter) MarkReady(ctx any, id any, objectKey any) *MockRepository_MarkReady_Call { + return &MockRepository_MarkReady_Call{Call: _e.mock.On("MarkReady", ctx, id, objectKey)} +} + +func (_c *MockRepository_MarkReady_Call) Run(run func(ctx context.Context, id uuid.UUID, objectKey string)) *MockRepository_MarkReady_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 uuid.UUID + if args[1] != nil { + arg1 = args[1].(uuid.UUID) + } + var arg2 string + if args[2] != nil { + arg2 = args[2].(string) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *MockRepository_MarkReady_Call) Return(attachment domain.Attachment, err error) *MockRepository_MarkReady_Call { + _c.Call.Return(attachment, err) + return _c +} + +func (_c *MockRepository_MarkReady_Call) RunAndReturn(run func(ctx context.Context, id uuid.UUID, objectKey string) (domain.Attachment, error)) *MockRepository_MarkReady_Call { + _c.Call.Return(run) + return _c +} diff --git a/internal/service/attachment/service.go b/internal/service/attachment/service.go new file mode 100644 index 00000000..aadf3c17 --- /dev/null +++ b/internal/service/attachment/service.go @@ -0,0 +1,487 @@ +package attachment + +import ( + "context" + "crypto/sha256" + "encoding/hex" + "errors" + "fmt" + "io" + "log/slog" + "net/http" + "os" + "regexp" + "strings" + "time" + "unicode" + "unicode/utf8" + + "github.com/google/uuid" + + "mtusi-messenger/internal/domain" + "mtusi-messenger/internal/imagecheck" + "mtusi-messenger/internal/platform/objectstore" +) + +const ( + contentTypePNG = "image/png" + contentTypeJPEG = "image/jpeg" + + objectPrefixAttachments = "attachments/" + objectPrefixStaging = "staging/" + objectPrefixPresign = "staging/presign/" +) + +var sha256Pattern = regexp.MustCompile(`^[0-9a-f]{64}$`) + +// Repository is the persistence port. It is consumer-side so the service can be +// tested without PostgreSQL. +type Repository interface { + IsChatMember(ctx context.Context, chatID, userID uuid.UUID) (bool, error) + Create(ctx context.Context, draft domain.AttachmentDraft) (domain.Attachment, error) + MarkReady(ctx context.Context, id uuid.UUID, objectKey string) (domain.Attachment, error) + DeletePending(ctx context.Context, id uuid.UUID) error + GetForMember(ctx context.Context, userID, id uuid.UUID) (domain.Attachment, error) + GetForOwner(ctx context.Context, ownerID, id uuid.UUID) (domain.Attachment, error) + ListStates(ctx context.Context, chatID uuid.UUID, ids []uuid.UUID) ([]domain.AttachmentState, error) + ListStalePending(ctx context.Context, createdBefore time.Time, limit int32) ([]domain.Attachment, error) + ListKeys(ctx context.Context, limit, offset int32) ([]domain.AttachmentKey, error) +} + +// Config carries the attachment limits. They are validated by config.Load. +type Config struct { + MaxUploadBytes int64 + MaxImagePixels int64 + PresignTTL time.Duration +} + +type Service struct { + repo Repository + store objectstore.Store + config Config + log *slog.Logger +} + +func NewService(repo Repository, store objectstore.Store, config Config, log *slog.Logger) *Service { + if log == nil { + log = slog.Default() + } + + return &Service{repo: repo, store: store, config: config, log: log} +} + +// UploadInput is one raw-body upload. DeclaredContentType comes from the HTTP +// Content-Type header and is cross-checked against the detected format. +type UploadInput struct { + ChatID uuid.UUID + OwnerID uuid.UUID + Filename string + DeclaredContentType string + Body io.Reader +} + +func (s *Service) Upload(ctx context.Context, input UploadInput) (domain.Attachment, error) { + if err := ValidateFilename(input.Filename); err != nil { + return domain.Attachment{}, err + } + + member, err := s.repo.IsChatMember(ctx, input.ChatID, input.OwnerID) + if err != nil { + return domain.Attachment{}, err + } + + if !member { + return domain.Attachment{}, fmt.Errorf("%w: chat is not visible", domain.ErrNotFound) + } + + file, size, sum, err := s.spool(input.Body) + if err != nil { + return domain.Attachment{}, err + } + + defer func() { _ = file.Close() }() + defer func() { _ = os.Remove(file.Name()) }() + + if _, err := file.Seek(0, io.SeekStart); err != nil { + return domain.Attachment{}, fmt.Errorf("rewind upload: %w", err) + } + + info, err := imagecheck.Validate(file, s.config.MaxImagePixels) + if err != nil { + return domain.Attachment{}, mapImageError(err) + } + + if info.ContentType != input.DeclaredContentType { + return domain.Attachment{}, fmt.Errorf( + "%w: declared %q, detected %q", + domain.ErrUnsupportedMedia, input.DeclaredContentType, info.ContentType, + ) + } + + id, err := uuid.NewV7() + if err != nil { + return domain.Attachment{}, fmt.Errorf("generate attachment id: %w", err) + } + + objectKey := objectPrefixAttachments + input.ChatID.String() + "/" + id.String() + + if _, err := s.repo.Create(ctx, domain.AttachmentDraft{ + ID: id, + ChatID: input.ChatID, + OwnerID: input.OwnerID, + ObjectKey: objectKey, + Filename: input.Filename, + ContentType: info.ContentType, + SizeBytes: size, + SHA256: sum, + }); err != nil { + return domain.Attachment{}, err + } + + if _, err := file.Seek(0, io.SeekStart); err != nil { + return domain.Attachment{}, fmt.Errorf("rewind upload: %w", err) + } + + if err := s.store.Put(ctx, objectKey, file, size, info.ContentType, map[string]string{"sha256": sum}); err != nil { + s.cleanupPending(ctx, id, "") + + return domain.Attachment{}, unavailable("store attachment", err) + } + + ready, err := s.repo.MarkReady(ctx, id, objectKey) + if err != nil { + // The object and the pending row remain; the sweeper either finalises + // the row or removes both after the grace period. The client must not + // receive 201 until metadata is committed. + return domain.Attachment{}, unavailable("commit attachment", err) + } + + return ready, nil +} + +func (s *Service) Get(ctx context.Context, callerID, id uuid.UUID) (domain.Attachment, error) { + attachment, err := s.repo.GetForMember(ctx, callerID, id) + if err != nil { + return domain.Attachment{}, err + } + + // Contract 1.4.0 declares Attachment.status as the single value "ready". + // Pending/failed rows therefore cannot be represented in a 200 response; + // they are reported as 409 until lab5 extends the enum. + if attachment.Status != domain.AttachmentReady { + return domain.Attachment{}, fmt.Errorf("%w: attachment is %s", domain.ErrConflict, attachment.Status) + } + + return attachment, nil +} + +// Open returns metadata and the original stream. Only ready attachments have +// bytes; pending/failed return 409 on the content endpoint. +func (s *Service) Open( + ctx context.Context, + callerID, id uuid.UUID, +) (domain.Attachment, io.ReadCloser, error) { + attachment, err := s.repo.GetForMember(ctx, callerID, id) + if err != nil { + return domain.Attachment{}, nil, err + } + + if attachment.Status != domain.AttachmentReady { + return domain.Attachment{}, nil, fmt.Errorf("%w: attachment is %s", domain.ErrConflict, attachment.Status) + } + + body, _, err := s.store.Open(ctx, attachment.ObjectKey) + if err != nil { + return domain.Attachment{}, nil, err + } + + return attachment, body, nil +} + +func (s *Service) Presign(ctx context.Context, request domain.PresignRequest) (domain.PresignResult, error) { + if err := ValidateFilename(request.Filename); err != nil { + return domain.PresignResult{}, err + } + + if request.ContentType != contentTypePNG && request.ContentType != contentTypeJPEG { + return domain.PresignResult{}, fmt.Errorf("%w: content type %q", domain.ErrUnsupportedMedia, request.ContentType) + } + + if request.SizeBytes < 1 || request.SizeBytes > s.config.MaxUploadBytes { + return domain.PresignResult{}, fmt.Errorf("%w: size %d", domain.ErrTooLarge, request.SizeBytes) + } + + if !sha256Pattern.MatchString(request.SHA256) { + return domain.PresignResult{}, fmt.Errorf("%w: sha256 must be 64 lowercase hex characters", domain.ErrValidation) + } + + member, err := s.repo.IsChatMember(ctx, request.ChatID, request.OwnerID) + if err != nil { + return domain.PresignResult{}, err + } + + if !member { + return domain.PresignResult{}, fmt.Errorf("%w: chat is not visible", domain.ErrNotFound) + } + + id, err := uuid.NewV7() + if err != nil { + return domain.PresignResult{}, fmt.Errorf("generate attachment id: %w", err) + } + + stagingKey := objectPrefixPresign + request.ChatID.String() + "/" + id.String() + + if _, err := s.repo.Create(ctx, domain.AttachmentDraft{ + ID: id, + ChatID: request.ChatID, + OwnerID: request.OwnerID, + ObjectKey: stagingKey, + Filename: request.Filename, + ContentType: request.ContentType, + SizeBytes: request.SizeBytes, + SHA256: request.SHA256, + }); err != nil { + return domain.PresignResult{}, err + } + + url, expiresAt, err := s.store.PresignPut(ctx, stagingKey, s.config.PresignTTL) + if err != nil { + s.cleanupPending(ctx, id, "") + + return domain.PresignResult{}, unavailable("presign attachment", err) + } + + return domain.PresignResult{ + AttachmentID: id, + UploadURL: url, + ExpiresAt: expiresAt, + SizeBytes: request.SizeBytes, + SHA256: request.SHA256, + }, nil +} + +func (s *Service) Complete( + ctx context.Context, + ownerID, id uuid.UUID, + requestSHA string, +) (domain.Attachment, error) { + if !sha256Pattern.MatchString(requestSHA) { + return domain.Attachment{}, fmt.Errorf("%w: sha256 must be 64 lowercase hex characters", domain.ErrValidation) + } + + attachment, err := s.repo.GetForOwner(ctx, ownerID, id) + if err != nil { + return domain.Attachment{}, err + } + + switch attachment.Status { + case domain.AttachmentReady: + if attachment.SHA256 != requestSHA { + return domain.Attachment{}, fmt.Errorf("%w: attachment already completed with another checksum", domain.ErrConflict) + } + + return attachment, nil + case domain.AttachmentFailed: + return domain.Attachment{}, fmt.Errorf("%w: attachment is failed", domain.ErrConflict) + case domain.AttachmentPending: + default: + return domain.Attachment{}, fmt.Errorf("%w: unknown attachment status", domain.ErrConflict) + } + + if !strings.HasPrefix(attachment.ObjectKey, objectPrefixPresign) { + return domain.Attachment{}, fmt.Errorf("%w: attachment is not a presigned upload", domain.ErrConflict) + } + + head, err := s.store.Head(ctx, attachment.ObjectKey) + if err != nil { + if errors.Is(err, domain.ErrNotFound) { + return domain.Attachment{}, fmt.Errorf("%w: object was not uploaded", domain.ErrIncomplete) + } + + return domain.Attachment{}, err + } + + if head.Size != attachment.SizeBytes { + s.cleanupPending(ctx, id, attachment.ObjectKey) + + return domain.Attachment{}, fmt.Errorf( + "%w: uploaded %d bytes, declared %d", + domain.ErrValidation, head.Size, attachment.SizeBytes, + ) + } + + body, _, err := s.store.Open(ctx, attachment.ObjectKey) + if err != nil { + return domain.Attachment{}, err + } + + hasher := sha256.New() + info, validateErr := imagecheck.Validate(io.TeeReader(body, hasher), s.config.MaxImagePixels) + closeErr := body.Close() + + if validateErr != nil { + s.cleanupPending(ctx, id, attachment.ObjectKey) + + return domain.Attachment{}, mapImageError(validateErr) + } + + if closeErr != nil { + return domain.Attachment{}, unavailable("read uploaded object", closeErr) + } + + if info.ContentType != attachment.ContentType { + s.cleanupPending(ctx, id, attachment.ObjectKey) + + return domain.Attachment{}, fmt.Errorf( + "%w: declared %q, detected %q", + domain.ErrUnsupportedMedia, attachment.ContentType, info.ContentType, + ) + } + + sum := hex.EncodeToString(hasher.Sum(nil)) + if sum != attachment.SHA256 { + s.cleanupPending(ctx, id, attachment.ObjectKey) + + return domain.Attachment{}, fmt.Errorf("%w: uploaded object checksum mismatch", domain.ErrValidation) + } + + if requestSHA != attachment.SHA256 { + s.cleanupPending(ctx, id, attachment.ObjectKey) + + return domain.Attachment{}, fmt.Errorf("%w: completion checksum mismatch", domain.ErrConflict) + } + + finalKey := objectPrefixAttachments + attachment.ChatID.String() + "/" + id.String() + + if err := s.store.Copy(ctx, attachment.ObjectKey, finalKey, attachment.ContentType, map[string]string{"sha256": sum}); err != nil { + return domain.Attachment{}, unavailable("publish attachment", err) + } + + ready, err := s.repo.MarkReady(ctx, id, finalKey) + if err != nil { + // A concurrent completion may have won. Re-read instead of reporting a + // spurious failure. + current, getErr := s.repo.GetForOwner(ctx, ownerID, id) + if getErr == nil && current.Status == domain.AttachmentReady && current.SHA256 == requestSHA { + return current, nil + } + + return domain.Attachment{}, unavailable("commit attachment", err) + } + + if err := s.store.Delete(ctx, attachment.ObjectKey); err != nil { + // The final object is already committed; a stale staging object is an + // orphan and the sweeper removes it after the grace period. + s.log.WarnContext(ctx, "staging object cleanup failed", + slog.String("attachment_id", id.String()), + slog.Any("error", err), + ) + } + + return ready, nil +} + +func (s *Service) spool(body io.Reader) (*os.File, int64, string, error) { + file, err := os.CreateTemp("", "lab4-upload-*") + if err != nil { + return nil, 0, "", fmt.Errorf("create upload spool: %w", err) + } + + cleanup := func() { + _ = file.Close() + _ = os.Remove(file.Name()) + } + + hasher := sha256.New() + limited := io.LimitReader(body, s.config.MaxUploadBytes+1) + buffer := make([]byte, 32<<10) + + size, err := io.CopyBuffer(io.MultiWriter(file, hasher), limited, buffer) + if err != nil { + cleanup() + + var maxBytes *http.MaxBytesError + if errors.As(err, &maxBytes) { + return nil, 0, "", fmt.Errorf("%w: request body exceeds %d bytes", domain.ErrTooLarge, s.config.MaxUploadBytes) + } + + return nil, 0, "", fmt.Errorf("%w: read upload: %w", domain.ErrValidation, err) + } + + if size > s.config.MaxUploadBytes { + cleanup() + + return nil, 0, "", fmt.Errorf("%w: upload exceeds %d bytes", domain.ErrTooLarge, s.config.MaxUploadBytes) + } + + if size == 0 { + cleanup() + + return nil, 0, "", fmt.Errorf("%w: empty image", domain.ErrUnsupportedMedia) + } + + return file, size, hex.EncodeToString(hasher.Sum(nil)), nil +} + +func (s *Service) cleanupPending(ctx context.Context, id uuid.UUID, objectKey string) { + if objectKey != "" { + if err := s.store.Delete(ctx, objectKey); err != nil && !errors.Is(err, domain.ErrNotFound) { + s.log.WarnContext(ctx, "object cleanup failed", + slog.String("attachment_id", id.String()), + slog.Any("error", err), + ) + } + } + + if err := s.repo.DeletePending(ctx, id); err != nil && !errors.Is(err, domain.ErrNotFound) { + s.log.WarnContext(ctx, "pending attachment cleanup failed", + slog.String("attachment_id", id.String()), + slog.Any("error", err), + ) + } +} + +// ValidateFilename implements the contract rule: 1-255 Unicode code points, +// no path separators, NUL or control characters. The name is display-only; the +// S3 key is always generated. +func ValidateFilename(name string) error { + if !utf8.ValidString(name) { + return fmt.Errorf("%w: filename is not valid UTF-8", domain.ErrValidation) + } + + length := utf8.RuneCountInString(name) + if length < 1 || length > 255 { + return fmt.Errorf("%w: filename length is %d, want 1-255 code points", domain.ErrValidation, length) + } + + if strings.ContainsAny(name, "/\\\x00") { + return fmt.Errorf("%w: filename contains a path separator or NUL", domain.ErrValidation) + } + + for _, r := range name { + if unicode.IsControl(r) { + return fmt.Errorf("%w: filename contains a control character", domain.ErrValidation) + } + } + + return nil +} + +func mapImageError(err error) error { + switch { + case errors.Is(err, imagecheck.ErrTooLarge): + return fmt.Errorf("%w: %w", domain.ErrTooLarge, err) + case errors.Is(err, imagecheck.ErrUnsupported), errors.Is(err, imagecheck.ErrCorrupt): + return fmt.Errorf("%w: %w", domain.ErrUnsupportedMedia, err) + default: + return err + } +} + +func unavailable(operation string, err error) error { + if errors.Is(err, domain.ErrUnavailable) || errors.Is(err, domain.ErrNotFound) { + return err + } + + return fmt.Errorf("%w: %s: %w", domain.ErrUnavailable, operation, err) +} diff --git a/internal/service/attachment/service_test.go b/internal/service/attachment/service_test.go new file mode 100644 index 00000000..22f917c1 --- /dev/null +++ b/internal/service/attachment/service_test.go @@ -0,0 +1,318 @@ +package attachment_test + +import ( + "bytes" + "context" + "crypto/sha256" + "encoding/hex" + "image" + "image/color" + "image/png" + "io" + "log/slog" + "strings" + "testing" + "time" + + "github.com/google/uuid" + "github.com/stretchr/testify/mock" + "github.com/stretchr/testify/require" + + "mtusi-messenger/internal/domain" + "mtusi-messenger/internal/platform/objectstore" + "mtusi-messenger/internal/service/attachment" + "mtusi-messenger/internal/service/attachment/mocks" +) + +type storedObject struct { + data []byte + contentType string + metadata map[string]string + lastModified time.Time +} + +type fakeStore struct { + objects map[string]storedObject +} + +func newFakeStore() *fakeStore { + return &fakeStore{objects: make(map[string]storedObject)} +} + +func (f *fakeStore) Put( + _ context.Context, + key string, + body io.ReadSeeker, + _ int64, + contentType string, + metadata map[string]string, +) error { + data, err := io.ReadAll(body) + if err != nil { + return err + } + + f.objects[key] = storedObject{ + data: data, + contentType: contentType, + metadata: metadata, + lastModified: time.Now().UTC(), + } + + return nil +} + +func (f *fakeStore) Open(_ context.Context, key string) (io.ReadCloser, objectstore.Object, error) { + object, ok := f.objects[key] + if !ok { + return nil, objectstore.Object{}, domain.ErrNotFound + } + + return io.NopCloser(bytes.NewReader(object.data)), f.object(key, object), nil +} + +func (f *fakeStore) Head(_ context.Context, key string) (objectstore.Object, error) { + object, ok := f.objects[key] + if !ok { + return objectstore.Object{}, domain.ErrNotFound + } + + return f.object(key, object), nil +} + +func (f *fakeStore) Copy(_ context.Context, src, dst, contentType string, metadata map[string]string) error { + object, ok := f.objects[src] + if !ok { + return domain.ErrNotFound + } + + f.objects[dst] = storedObject{ + data: append([]byte(nil), object.data...), + contentType: contentType, + metadata: metadata, + lastModified: time.Now().UTC(), + } + + return nil +} + +func (f *fakeStore) Delete(_ context.Context, key string) error { + delete(f.objects, key) + return nil +} + +func (f *fakeStore) List(_ context.Context, prefix string) ([]objectstore.Object, error) { + objects := make([]objectstore.Object, 0, len(f.objects)) + for key, object := range f.objects { + if strings.HasPrefix(key, prefix) { + objects = append(objects, f.object(key, object)) + } + } + + return objects, nil +} + +func (f *fakeStore) PresignPut(_ context.Context, key string, ttl time.Duration) (string, time.Time, error) { + return "http://s3.example/" + key, time.Now().UTC().Add(ttl), nil +} + +func (f *fakeStore) object(key string, object storedObject) objectstore.Object { + return objectstore.Object{ + Key: key, + Size: int64(len(object.data)), + ContentType: object.contentType, + LastModified: object.lastModified, + Metadata: object.metadata, + } +} + +func pngBytes(t *testing.T, width, height int) []byte { + t.Helper() + + source := image.NewRGBA(image.Rect(0, 0, width, height)) + for x := range width { + for y := range height { + source.Set(x, y, color.RGBA{R: uint8(x), G: uint8(y), B: 200, A: 255}) + } + } + + var buffer bytes.Buffer + require.NoError(t, png.Encode(&buffer, source)) + + return buffer.Bytes() +} + +func serviceConfig() attachment.Config { + return attachment.Config{ + MaxUploadBytes: 1 << 20, + MaxImagePixels: 1_000_000, + PresignTTL: 5 * time.Minute, + } +} + +func TestValidateFilename(t *testing.T) { + valid := []string{"photo.png", "фото.png", "a b.jpeg", strings.Repeat("я", 255)} + for _, name := range valid { + require.NoError(t, attachment.ValidateFilename(name), name) + } + + invalid := []string{"", strings.Repeat("x", 256), "a/b.png", `a\b.png`, "a\x00b.png", "a\nb.png"} + for _, name := range invalid { + require.ErrorIs(t, attachment.ValidateFilename(name), domain.ErrValidation, name) + } +} + +func TestUploadStoresOriginal(t *testing.T) { + repo := mocks.NewMockRepository(t) + store := newFakeStore() + service := attachment.NewService(repo, store, serviceConfig(), slog.Default()) + + chatID := uuid.New() + ownerID := uuid.New() + content := pngBytes(t, 16, 16) + sum := sha256.Sum256(content) + + repo.EXPECT().IsChatMember(mock.Anything, chatID, ownerID).Return(true, nil).Once() + repo.EXPECT().Create(mock.Anything, mock.MatchedBy(func(draft domain.AttachmentDraft) bool { + return draft.ChatID == chatID && draft.OwnerID == ownerID && + draft.ContentType == "image/png" && draft.SizeBytes == int64(len(content)) && + draft.SHA256 == hex.EncodeToString(sum[:]) && strings.HasPrefix(draft.ObjectKey, "attachments/") + })).Return(domain.Attachment{Status: domain.AttachmentPending}, nil).Once() + repo.EXPECT().MarkReady(mock.Anything, mock.Anything, mock.Anything). + Return(domain.Attachment{Status: domain.AttachmentReady, ContentType: "image/png", SizeBytes: int64(len(content))}, nil). + Once() + + result, err := service.Upload(t.Context(), attachment.UploadInput{ + ChatID: chatID, + OwnerID: ownerID, + Filename: "photo.png", + DeclaredContentType: "image/png", + Body: bytes.NewReader(content), + }) + require.NoError(t, err) + require.Equal(t, domain.AttachmentReady, result.Status) + require.Len(t, store.objects, 1) +} + +func TestUploadRejectsTooLargeBody(t *testing.T) { + repo := mocks.NewMockRepository(t) + service := attachment.NewService(repo, newFakeStore(), attachment.Config{ + MaxUploadBytes: 8, + MaxImagePixels: 1_000_000, + PresignTTL: time.Minute, + }, slog.Default()) + + repo.EXPECT().IsChatMember(mock.Anything, mock.Anything, mock.Anything).Return(true, nil).Once() + + _, err := service.Upload(t.Context(), attachment.UploadInput{ + ChatID: uuid.New(), + OwnerID: uuid.New(), + Filename: "photo.png", + DeclaredContentType: "image/png", + Body: bytes.NewReader(bytes.Repeat([]byte("x"), 9)), + }) + + require.ErrorIs(t, err, domain.ErrTooLarge) +} + +func TestUploadRejectsMIMEMismatch(t *testing.T) { + repo := mocks.NewMockRepository(t) + service := attachment.NewService(repo, newFakeStore(), serviceConfig(), slog.Default()) + + repo.EXPECT().IsChatMember(mock.Anything, mock.Anything, mock.Anything).Return(true, nil).Once() + + _, err := service.Upload(t.Context(), attachment.UploadInput{ + ChatID: uuid.New(), + OwnerID: uuid.New(), + Filename: "photo.jpg", + DeclaredContentType: "image/jpeg", + Body: bytes.NewReader(pngBytes(t, 8, 8)), + }) + + require.ErrorIs(t, err, domain.ErrUnsupportedMedia) +} + +func TestGetRejectsNonReadyAttachment(t *testing.T) { + repo := mocks.NewMockRepository(t) + service := attachment.NewService(repo, newFakeStore(), serviceConfig(), slog.Default()) + + repo.EXPECT().GetForMember(mock.Anything, mock.Anything, mock.Anything). + Return(domain.Attachment{Status: domain.AttachmentPending}, nil).Once() + + _, err := service.Get(t.Context(), uuid.New(), uuid.New()) + require.ErrorIs(t, err, domain.ErrConflict) +} + +func TestCompletePublishesPresignedObject(t *testing.T) { + repo := mocks.NewMockRepository(t) + store := newFakeStore() + service := attachment.NewService(repo, store, serviceConfig(), slog.Default()) + + id := uuid.New() + chatID := uuid.New() + ownerID := uuid.New() + content := pngBytes(t, 10, 10) + sum := sha256.Sum256(content) + digest := hex.EncodeToString(sum[:]) + stagingKey := "staging/presign/" + chatID.String() + "/" + id.String() + + store.objects[stagingKey] = storedObject{ + data: content, + contentType: "image/png", + metadata: map[string]string{"sha256": digest}, + lastModified: time.Now().UTC(), + } + + pending := domain.Attachment{ + ID: id, ChatID: chatID, OwnerID: ownerID, ObjectKey: stagingKey, + ContentType: "image/png", SizeBytes: int64(len(content)), SHA256: digest, + Status: domain.AttachmentPending, + } + + repo.EXPECT().GetForOwner(mock.Anything, ownerID, id).Return(pending, nil).Once() + repo.EXPECT().MarkReady(mock.Anything, id, mock.MatchedBy(func(key string) bool { + return strings.HasPrefix(key, "attachments/") + })).Return(domain.Attachment{ + ID: id, ChatID: chatID, OwnerID: ownerID, ContentType: "image/png", + SizeBytes: int64(len(content)), SHA256: digest, Status: domain.AttachmentReady, + }, nil).Once() + + completed, err := service.Complete(t.Context(), ownerID, id, digest) + require.NoError(t, err) + require.Equal(t, domain.AttachmentReady, completed.Status) + require.NotContains(t, store.objects, stagingKey) + require.Len(t, store.objects, 1) +} + +func TestCompleteRejectsChecksumMismatch(t *testing.T) { + repo := mocks.NewMockRepository(t) + store := newFakeStore() + service := attachment.NewService(repo, store, serviceConfig(), slog.Default()) + + id := uuid.New() + chatID := uuid.New() + ownerID := uuid.New() + content := pngBytes(t, 10, 10) + sum := sha256.Sum256(content) + digest := hex.EncodeToString(sum[:]) + stagingKey := "staging/presign/" + chatID.String() + "/" + id.String() + + store.objects[stagingKey] = storedObject{ + data: content, + contentType: "image/png", + metadata: map[string]string{"sha256": digest}, + } + + pending := domain.Attachment{ + ID: id, ChatID: chatID, OwnerID: ownerID, ObjectKey: stagingKey, + ContentType: "image/png", SizeBytes: int64(len(content)) + 1, SHA256: digest, + Status: domain.AttachmentPending, + } + + repo.EXPECT().GetForOwner(mock.Anything, ownerID, id).Return(pending, nil).Once() + repo.EXPECT().DeletePending(mock.Anything, id).Return(nil).Once() + + _, err := service.Complete(t.Context(), ownerID, id, digest) + require.ErrorIs(t, err, domain.ErrValidation) + require.NotContains(t, store.objects, stagingKey) +} diff --git a/internal/service/attachment/sweeper.go b/internal/service/attachment/sweeper.go new file mode 100644 index 00000000..cc12552d --- /dev/null +++ b/internal/service/attachment/sweeper.go @@ -0,0 +1,235 @@ +package attachment + +import ( + "context" + "errors" + "log/slog" + "strings" + "time" + + "mtusi-messenger/internal/domain" + "mtusi-messenger/internal/platform/objectstore" +) + +// LockStore serialises sweepers across API replicas. +type LockStore interface { + AcquireSweepLock(ctx context.Context) (release func(), acquired bool, err error) +} + +type SweepStats struct { + Recovered int + RowsDeleted int + ObjectsDeleted int +} + +type Sweeper struct { + repo Repository + store objectstore.Store + locker LockStore + grace time.Duration + interval time.Duration + log *slog.Logger +} + +func NewSweeper( + repo Repository, + store objectstore.Store, + locker LockStore, + grace, interval time.Duration, + log *slog.Logger, +) *Sweeper { + if log == nil { + log = slog.Default() + } + + return &Sweeper{ + repo: repo, + store: store, + locker: locker, + grace: grace, + interval: interval, + log: log, + } +} + +// Run sweeps immediately, then on every interval until the context is done. +func (s *Sweeper) Run(ctx context.Context) { + s.sweep(ctx) + + ticker := time.NewTicker(s.interval) + defer ticker.Stop() + + for { + select { + case <-ctx.Done(): + return + case <-ticker.C: + s.sweep(ctx) + } + } +} + +func (s *Sweeper) sweep(ctx context.Context) { + stats, err := s.SweepOnce(ctx) + if err != nil { + s.log.WarnContext(ctx, "attachment sweep failed", slog.Any("error", err)) + + return + } + + if stats.Recovered+stats.RowsDeleted+stats.ObjectsDeleted > 0 { + s.log.InfoContext(ctx, "attachment sweep finished", + slog.Int("recovered", stats.Recovered), + slog.Int("rows_deleted", stats.RowsDeleted), + slog.Int("objects_deleted", stats.ObjectsDeleted), + ) + } +} + +// SweepOnce reconciles PostgreSQL metadata with S3 objects. It never deletes a +// ready row or an object referenced by any row. Only objects older than the +// grace period are candidates, so an in-flight upload cannot be collected. +func (s *Sweeper) SweepOnce(ctx context.Context) (SweepStats, error) { + release, acquired, err := s.locker.AcquireSweepLock(ctx) + if err != nil { + return SweepStats{}, err + } + + if !acquired { + return SweepStats{}, nil + } + + defer release() + + before := time.Now().UTC().Add(-s.grace) + + var stats SweepStats + + stale, err := s.repo.ListStalePending(ctx, before, 100) + if err != nil { + return stats, err + } + + for _, row := range stale { + if row.Status != domain.AttachmentPending { + continue + } + + if strings.HasPrefix(row.ObjectKey, objectPrefixPresign) { + if s.deleteObject(ctx, row.ObjectKey) { + stats.ObjectsDeleted++ + } + + if err := s.repo.DeletePending(ctx, row.ID); err != nil && !errors.Is(err, domain.ErrNotFound) { + return stats, err + } + + stats.RowsDeleted++ + continue + } + + // A proxy upload writes directly to its final key. If the process died + // between PutObject and MarkReady, the object is complete and can be + // recovered instead of discarded. + head, err := s.store.Head(ctx, row.ObjectKey) + if err != nil { + if errors.Is(err, domain.ErrNotFound) { + if err := s.repo.DeletePending(ctx, row.ID); err != nil && !errors.Is(err, domain.ErrNotFound) { + return stats, err + } + + stats.RowsDeleted++ + continue + } + + s.log.WarnContext(ctx, "sweep head failed", + slog.String("attachment_id", row.ID.String()), + slog.Any("error", err), + ) + + continue + } + + if head.Size == row.SizeBytes && head.Metadata["sha256"] == row.SHA256 { + if _, err := s.repo.MarkReady(ctx, row.ID, row.ObjectKey); err == nil { + stats.Recovered++ + continue + } + } + + if s.deleteObject(ctx, row.ObjectKey) { + stats.ObjectsDeleted++ + } + + if err := s.repo.DeletePending(ctx, row.ID); err != nil && !errors.Is(err, domain.ErrNotFound) { + return stats, err + } + + stats.RowsDeleted++ + } + + referenced, err := s.referencedKeys(ctx) + if err != nil { + return stats, err + } + + for _, prefix := range []string{objectPrefixAttachments, objectPrefixStaging} { + objects, err := s.store.List(ctx, prefix) + if err != nil { + return stats, err + } + + for _, object := range objects { + if object.LastModified.IsZero() || !object.LastModified.Before(before) { + continue + } + + if _, ok := referenced[object.Key]; ok { + continue + } + + if s.deleteObject(ctx, object.Key) { + stats.ObjectsDeleted++ + } + } + } + + return stats, nil +} + +func (s *Sweeper) referencedKeys(ctx context.Context) (map[string]struct{}, error) { + const pageSize = 1000 + + keys := make(map[string]struct{}) + + for offset := int32(0); ; offset += pageSize { + rows, err := s.repo.ListKeys(ctx, pageSize, offset) + if err != nil { + return nil, err + } + + for _, row := range rows { + keys[row.ObjectKey] = struct{}{} + } + + if len(rows) < pageSize { + return keys, nil + } + } +} + +func (s *Sweeper) deleteObject(ctx context.Context, key string) bool { + err := s.store.Delete(ctx, key) + if err == nil { + return true + } + + if !errors.Is(err, domain.ErrNotFound) { + s.log.WarnContext(ctx, "sweep delete failed", + slog.String("object_key", key), + slog.Any("error", err), + ) + } + + return false +} diff --git a/internal/service/attachment/sweeper_test.go b/internal/service/attachment/sweeper_test.go new file mode 100644 index 00000000..6c19cdd2 --- /dev/null +++ b/internal/service/attachment/sweeper_test.go @@ -0,0 +1,90 @@ +package attachment_test + +import ( + "log/slog" + "testing" + "time" + + "github.com/google/uuid" + "github.com/stretchr/testify/mock" + "github.com/stretchr/testify/require" + + "mtusi-messenger/internal/domain" + "mtusi-messenger/internal/service/attachment" + "mtusi-messenger/internal/service/attachment/mocks" +) + +func TestSweepReconcilesPendingAndOrphanObjects(t *testing.T) { + repo := mocks.NewMockRepository(t) + locker := mocks.NewMockLockStore(t) + store := newFakeStore() + + stale := time.Now().UTC().Add(-time.Hour) + + presign := domain.Attachment{ + ID: uuid.New(), ObjectKey: "staging/presign/chat/" + uuid.NewString(), + Status: domain.AttachmentPending, CreatedAt: stale, + } + proxyRecoverable := domain.Attachment{ + ID: uuid.New(), ObjectKey: "attachments/chat/" + uuid.NewString(), + SizeBytes: 3, SHA256: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + Status: domain.AttachmentPending, CreatedAt: stale, + } + proxyMissing := domain.Attachment{ + ID: uuid.New(), ObjectKey: "attachments/chat/" + uuid.NewString(), + Status: domain.AttachmentPending, CreatedAt: stale, + } + readyKey := "attachments/chat/ready" + + store.objects[presign.ObjectKey] = storedObject{data: []byte("x"), lastModified: stale} + store.objects[proxyRecoverable.ObjectKey] = storedObject{ + data: []byte("abc"), + lastModified: stale, + metadata: map[string]string{"sha256": proxyRecoverable.SHA256}, + } + store.objects[readyKey] = storedObject{data: []byte("ready"), lastModified: stale} + store.objects["attachments/chat/orphan"] = storedObject{data: []byte("orphan"), lastModified: stale} + store.objects["staging/abandoned"] = storedObject{data: []byte("stale"), lastModified: stale} + store.objects["staging/fresh"] = storedObject{data: []byte("fresh"), lastModified: time.Now().UTC()} + + repo.EXPECT().ListStalePending(mock.Anything, mock.Anything, int32(100)). + Return([]domain.Attachment{presign, proxyRecoverable, proxyMissing}, nil).Once() + repo.EXPECT().DeletePending(mock.Anything, presign.ID).Return(nil).Once() + repo.EXPECT().MarkReady(mock.Anything, proxyRecoverable.ID, proxyRecoverable.ObjectKey). + Return(domain.Attachment{ID: proxyRecoverable.ID, Status: domain.AttachmentReady}, nil).Once() + repo.EXPECT().DeletePending(mock.Anything, proxyMissing.ID).Return(nil).Once() + repo.EXPECT().ListKeys(mock.Anything, int32(1000), int32(0)). + Return([]domain.AttachmentKey{ + {ID: proxyRecoverable.ID, ObjectKey: proxyRecoverable.ObjectKey, Status: domain.AttachmentReady}, + {ID: uuid.New(), ObjectKey: readyKey, Status: domain.AttachmentReady}, + }, nil).Once() + locker.EXPECT().AcquireSweepLock(mock.Anything). + Return(func() {}, true, nil).Once() + + sweeper := attachment.NewSweeper(repo, store, locker, time.Minute, time.Hour, slog.Default()) + + stats, err := sweeper.SweepOnce(t.Context()) + require.NoError(t, err) + require.Equal(t, 1, stats.Recovered) + require.Equal(t, 2, stats.RowsDeleted) + require.Equal(t, 3, stats.ObjectsDeleted) + + require.NotContains(t, store.objects, presign.ObjectKey) + require.NotContains(t, store.objects, "attachments/chat/orphan") + require.NotContains(t, store.objects, "staging/abandoned") + require.Contains(t, store.objects, proxyRecoverable.ObjectKey) + require.Contains(t, store.objects, readyKey) + require.Contains(t, store.objects, "staging/fresh") +} + +func TestSweepSkipsWhenAnotherReplicaHoldsTheLock(t *testing.T) { + repo := mocks.NewMockRepository(t) + locker := mocks.NewMockLockStore(t) + sweeper := attachment.NewSweeper(repo, newFakeStore(), locker, time.Minute, time.Hour, slog.Default()) + + locker.EXPECT().AcquireSweepLock(mock.Anything).Return(nil, false, nil).Once() + + stats, err := sweeper.SweepOnce(t.Context()) + require.NoError(t, err) + require.Zero(t, stats) +} diff --git a/internal/service/message/mocks/AttachmentChecker.go b/internal/service/message/mocks/AttachmentChecker.go new file mode 100644 index 00000000..6a21beda --- /dev/null +++ b/internal/service/message/mocks/AttachmentChecker.go @@ -0,0 +1,123 @@ +// Code generated by mockery; DO NOT EDIT. +// github.com/vektra/mockery +// template: testify + +package mocks + +import ( + "context" + "mtusi-messenger/internal/domain" + + "github.com/google/uuid" + mock "github.com/stretchr/testify/mock" +) + +// NewMockAttachmentChecker creates a new instance of MockAttachmentChecker. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockAttachmentChecker(t interface { + mock.TestingT + Cleanup(func()) +}) *MockAttachmentChecker { + if helper, ok := t.(interface{ Helper() }); ok { + helper.Helper() + } + + mock := &MockAttachmentChecker{} + mock.Mock.Test(t) + + t.Cleanup(func() { + if helper, ok := t.(interface{ Helper() }); ok { + helper.Helper() + } + mock.AssertExpectations(t) + }) + + return mock +} + +// MockAttachmentChecker is an autogenerated mock type for the AttachmentChecker type +type MockAttachmentChecker struct { + mock.Mock +} + +type MockAttachmentChecker_Expecter struct { + mock *mock.Mock +} + +func (_m *MockAttachmentChecker) EXPECT() *MockAttachmentChecker_Expecter { + return &MockAttachmentChecker_Expecter{mock: &_m.Mock} +} + +// ListStates provides a mock function for the type MockAttachmentChecker +func (_mock *MockAttachmentChecker) ListStates(ctx context.Context, chatID uuid.UUID, ids []uuid.UUID) ([]domain.AttachmentState, error) { + ret := _mock.Called(ctx, chatID, ids) + + if len(ret) == 0 { + panic("no return value specified for ListStates") + } + + var r0 []domain.AttachmentState + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, uuid.UUID, []uuid.UUID) ([]domain.AttachmentState, error)); ok { + return returnFunc(ctx, chatID, ids) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, uuid.UUID, []uuid.UUID) []domain.AttachmentState); ok { + r0 = returnFunc(ctx, chatID, ids) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]domain.AttachmentState) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, uuid.UUID, []uuid.UUID) error); ok { + r1 = returnFunc(ctx, chatID, ids) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAttachmentChecker_ListStates_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListStates' +type MockAttachmentChecker_ListStates_Call struct { + *mock.Call +} + +// ListStates is a helper method to define mock.On call +// - ctx context.Context +// - chatID uuid.UUID +// - ids []uuid.UUID +func (_e *MockAttachmentChecker_Expecter) ListStates(ctx any, chatID any, ids any) *MockAttachmentChecker_ListStates_Call { + return &MockAttachmentChecker_ListStates_Call{Call: _e.mock.On("ListStates", ctx, chatID, ids)} +} + +func (_c *MockAttachmentChecker_ListStates_Call) Run(run func(ctx context.Context, chatID uuid.UUID, ids []uuid.UUID)) *MockAttachmentChecker_ListStates_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 uuid.UUID + if args[1] != nil { + arg1 = args[1].(uuid.UUID) + } + var arg2 []uuid.UUID + if args[2] != nil { + arg2 = args[2].([]uuid.UUID) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *MockAttachmentChecker_ListStates_Call) Return(attachmentStates []domain.AttachmentState, err error) *MockAttachmentChecker_ListStates_Call { + _c.Call.Return(attachmentStates, err) + return _c +} + +func (_c *MockAttachmentChecker_ListStates_Call) RunAndReturn(run func(ctx context.Context, chatID uuid.UUID, ids []uuid.UUID) ([]domain.AttachmentState, error)) *MockAttachmentChecker_ListStates_Call { + _c.Call.Return(run) + return _c +} diff --git a/internal/service/message/mocks/Repository.go b/internal/service/message/mocks/Repository.go index b09b4656..f07fe488 100644 --- a/internal/service/message/mocks/Repository.go +++ b/internal/service/message/mocks/Repository.go @@ -114,6 +114,78 @@ func (_c *MockRepository_Create_Call) RunAndReturn(run func(ctx context.Context, return _c } +// IsChatMember provides a mock function for the type MockRepository +func (_mock *MockRepository) IsChatMember(ctx context.Context, chatID uuid.UUID, userID uuid.UUID) (bool, error) { + ret := _mock.Called(ctx, chatID, userID) + + if len(ret) == 0 { + panic("no return value specified for IsChatMember") + } + + var r0 bool + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, uuid.UUID, uuid.UUID) (bool, error)); ok { + return returnFunc(ctx, chatID, userID) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, uuid.UUID, uuid.UUID) bool); ok { + r0 = returnFunc(ctx, chatID, userID) + } else { + r0 = ret.Get(0).(bool) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, uuid.UUID, uuid.UUID) error); ok { + r1 = returnFunc(ctx, chatID, userID) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockRepository_IsChatMember_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsChatMember' +type MockRepository_IsChatMember_Call struct { + *mock.Call +} + +// IsChatMember is a helper method to define mock.On call +// - ctx context.Context +// - chatID uuid.UUID +// - userID uuid.UUID +func (_e *MockRepository_Expecter) IsChatMember(ctx any, chatID any, userID any) *MockRepository_IsChatMember_Call { + return &MockRepository_IsChatMember_Call{Call: _e.mock.On("IsChatMember", ctx, chatID, userID)} +} + +func (_c *MockRepository_IsChatMember_Call) Run(run func(ctx context.Context, chatID uuid.UUID, userID uuid.UUID)) *MockRepository_IsChatMember_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 uuid.UUID + if args[1] != nil { + arg1 = args[1].(uuid.UUID) + } + var arg2 uuid.UUID + if args[2] != nil { + arg2 = args[2].(uuid.UUID) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *MockRepository_IsChatMember_Call) Return(b bool, err error) *MockRepository_IsChatMember_Call { + _c.Call.Return(b, err) + return _c +} + +func (_c *MockRepository_IsChatMember_Call) RunAndReturn(run func(ctx context.Context, chatID uuid.UUID, userID uuid.UUID) (bool, error)) *MockRepository_IsChatMember_Call { + _c.Call.Return(run) + return _c +} + // ListVisible provides a mock function for the type MockRepository func (_mock *MockRepository) ListVisible(ctx context.Context, chatID uuid.UUID, callerID uuid.UUID, after *domain.Cursor, limit int) (domain.Page[domain.Message], error) { ret := _mock.Called(ctx, chatID, callerID, after, limit) diff --git a/internal/service/message/service.go b/internal/service/message/service.go index cbeb4c23..7f5c12d0 100644 --- a/internal/service/message/service.go +++ b/internal/service/message/service.go @@ -10,6 +10,7 @@ import ( ) type Repository interface { + IsChatMember(ctx context.Context, chatID, userID uuid.UUID) (bool, error) Create(ctx context.Context, draft domain.MessageDraft) (domain.Message, error) ListVisible( ctx context.Context, @@ -19,12 +20,20 @@ type Repository interface { ) (domain.Page[domain.Message], error) } -type Service struct { - messages Repository +// AttachmentChecker validates that requested attachments exist in the chat and +// are ready. The contract returns 404 for unknown/foreign IDs and 409 for +// attachments that cannot be linked. +type AttachmentChecker interface { + ListStates(ctx context.Context, chatID uuid.UUID, ids []uuid.UUID) ([]domain.AttachmentState, error) } -func NewService(messages Repository) *Service { - return &Service{messages: messages} +type Service struct { + messages Repository + attachments AttachmentChecker +} + +func NewService(messages Repository, attachments AttachmentChecker) *Service { + return &Service{messages: messages, attachments: attachments} } func (s *Service) Send(ctx context.Context, draft domain.MessageDraft) (domain.Message, error) { @@ -32,6 +41,39 @@ func (s *Service) Send(ctx context.Context, draft domain.MessageDraft) (domain.M return domain.Message{}, err } + member, err := s.messages.IsChatMember(ctx, draft.ChatID, draft.SenderID) + if err != nil { + return domain.Message{}, fmt.Errorf("check chat membership: %w", err) + } + + if !member { + return domain.Message{}, fmt.Errorf("%w: chat is not visible", domain.ErrNotFound) + } + + if len(draft.AttachmentIDs) > 0 { + if s.attachments == nil { + return domain.Message{}, fmt.Errorf("attachment checker is not configured: %w", domain.ErrUnavailable) + } + + states, err := s.attachments.ListStates(ctx, draft.ChatID, draft.AttachmentIDs) + if err != nil { + return domain.Message{}, fmt.Errorf("check attachments: %w", err) + } + + if len(states) != len(draft.AttachmentIDs) { + return domain.Message{}, fmt.Errorf("%w: attachment is not visible", domain.ErrNotFound) + } + + for _, state := range states { + if state.Status != domain.AttachmentReady { + return domain.Message{}, fmt.Errorf( + "%w: attachment %s is %s", + domain.ErrConflict, state.ID, state.Status, + ) + } + } + } + sent, err := s.messages.Create(ctx, draft) if err != nil { return domain.Message{}, fmt.Errorf("create message: %w", err) diff --git a/internal/service/message/service_test.go b/internal/service/message/service_test.go index 8051799d..2f703d72 100644 --- a/internal/service/message/service_test.go +++ b/internal/service/message/service_test.go @@ -18,11 +18,12 @@ var errRepository = errors.New("repository is unavailable") type ServiceSuite struct { suite.Suite - messages *mocks.MockRepository - service *message.Service - caller uuid.UUID - chatID uuid.UUID - now time.Time + messages *mocks.MockRepository + attachments *mocks.MockAttachmentChecker + service *message.Service + caller uuid.UUID + chatID uuid.UUID + now time.Time } func TestServiceSuite(t *testing.T) { @@ -32,7 +33,8 @@ func TestServiceSuite(t *testing.T) { func (s *ServiceSuite) SetupTest() { s.messages = mocks.NewMockRepository(s.T()) - s.service = message.NewService(s.messages) + s.attachments = mocks.NewMockAttachmentChecker(s.T()) + s.service = message.NewService(s.messages, s.attachments) s.caller = uuid.New() s.chatID = uuid.New() s.now = time.Date(2026, 9, 1, 12, 0, 0, 0, time.UTC) @@ -57,6 +59,7 @@ func (s *ServiceSuite) TestSendReturnsStoredMessage() { CreatedAt: s.now, } + s.messages.EXPECT().IsChatMember(s.T().Context(), draft.ChatID, draft.SenderID).Return(true, nil).Once() s.messages.EXPECT().Create(s.T().Context(), draft).Return(stored, nil).Once() got, err := s.service.Send(s.T().Context(), draft) @@ -76,11 +79,11 @@ func (s *ServiceSuite) TestSendRejectsWhitespaceTextWithoutRepositoryCall() { func (s *ServiceSuite) TestSendPropagatesNotFoundForOutsider() { draft := s.draft() - s.messages.EXPECT().Create(s.T().Context(), draft).Return(domain.Message{}, domain.ErrNotFound).Once() + s.messages.EXPECT().IsChatMember(s.T().Context(), draft.ChatID, draft.SenderID).Return(false, nil).Once() _, err := s.service.Send(s.T().Context(), draft) s.Require().ErrorIs(err, domain.ErrNotFound, - "доступ проверяет хранилище атомарно со вставкой") + "посторонний не должен узнать о существовании чата") } func (s *ServiceSuite) TestHistoryPassesNilCursorOnFirstPage() { @@ -142,3 +145,80 @@ func (s *ServiceSuite) TestHistoryWrapsRepositoryFailure() { _, err := s.service.History(s.T().Context(), s.caller, s.chatID, nil, domain.DefaultPageLimit) s.Require().ErrorIs(err, errRepository) } + +func (s *ServiceSuite) TestSendAcceptsReadyAttachment() { + attachmentID := uuid.New() + draft := s.draft() + draft.AttachmentIDs = []uuid.UUID{attachmentID} + stored := domain.Message{ + ID: uuid.New(), ChatID: draft.ChatID, SenderID: draft.SenderID, + AttachmentIDs: []uuid.UUID{attachmentID}, CreatedAt: s.now, + } + + s.messages.EXPECT().IsChatMember(s.T().Context(), draft.ChatID, draft.SenderID).Return(true, nil).Once() + s.attachments.EXPECT(). + ListStates(s.T().Context(), draft.ChatID, []uuid.UUID{attachmentID}). + Return([]domain.AttachmentState{{ID: attachmentID, Status: domain.AttachmentReady}}, nil). + Once() + s.messages.EXPECT().Create(s.T().Context(), draft).Return(stored, nil).Once() + + got, err := s.service.Send(s.T().Context(), draft) + s.Require().NoError(err) + s.Equal([]uuid.UUID{attachmentID}, got.AttachmentIDs) +} + +func (s *ServiceSuite) TestSendAllowsAttachmentOnlyMessage() { + attachmentID := uuid.New() + draft := s.draft() + draft.Text = "" + draft.AttachmentIDs = []uuid.UUID{attachmentID} + + s.messages.EXPECT().IsChatMember(s.T().Context(), draft.ChatID, draft.SenderID).Return(true, nil).Once() + s.attachments.EXPECT(). + ListStates(s.T().Context(), draft.ChatID, []uuid.UUID{attachmentID}). + Return([]domain.AttachmentState{{ID: attachmentID, Status: domain.AttachmentReady}}, nil). + Once() + s.messages.EXPECT().Create(s.T().Context(), draft).Return(domain.Message{AttachmentIDs: draft.AttachmentIDs}, nil).Once() + + _, err := s.service.Send(s.T().Context(), draft) + s.Require().NoError(err) +} + +func (s *ServiceSuite) TestSendRejectsForeignAttachment() { + attachmentID := uuid.New() + draft := s.draft() + draft.AttachmentIDs = []uuid.UUID{attachmentID} + + s.messages.EXPECT().IsChatMember(s.T().Context(), draft.ChatID, draft.SenderID).Return(true, nil).Once() + s.attachments.EXPECT(). + ListStates(s.T().Context(), draft.ChatID, []uuid.UUID{attachmentID}). + Return([]domain.AttachmentState{}, nil). + Once() + + _, err := s.service.Send(s.T().Context(), draft) + s.Require().ErrorIs(err, domain.ErrNotFound) +} + +func (s *ServiceSuite) TestSendRejectsPendingAttachment() { + attachmentID := uuid.New() + draft := s.draft() + draft.AttachmentIDs = []uuid.UUID{attachmentID} + + s.messages.EXPECT().IsChatMember(s.T().Context(), draft.ChatID, draft.SenderID).Return(true, nil).Once() + s.attachments.EXPECT(). + ListStates(s.T().Context(), draft.ChatID, []uuid.UUID{attachmentID}). + Return([]domain.AttachmentState{{ID: attachmentID, Status: domain.AttachmentPending}}, nil). + Once() + + _, err := s.service.Send(s.T().Context(), draft) + s.Require().ErrorIs(err, domain.ErrConflict) +} + +func (s *ServiceSuite) TestSendRejectsDuplicateAttachments() { + id := uuid.New() + draft := s.draft() + draft.AttachmentIDs = []uuid.UUID{id, id} + + _, err := s.service.Send(s.T().Context(), draft) + s.Require().ErrorIs(err, domain.ErrValidation) +} diff --git a/internal/storage/postgres/attachment_repository.go b/internal/storage/postgres/attachment_repository.go new file mode 100644 index 00000000..3caa97e9 --- /dev/null +++ b/internal/storage/postgres/attachment_repository.go @@ -0,0 +1,215 @@ +package postgres + +import ( + "context" + "fmt" + "time" + + "github.com/google/uuid" + + "mtusi-messenger/internal/domain" + "mtusi-messenger/internal/storage/postgres/internal/sqlcgen" +) + +type AttachmentRepository struct { + store *Store +} + +func (r *AttachmentRepository) IsChatMember(ctx context.Context, chatID, userID uuid.UUID) (bool, error) { + ctx, cancel := r.store.timeout(ctx) + defer cancel() + + member, err := r.store.queries.IsChatMember(ctx, sqlcgen.IsChatMemberParams{ + ChatID: chatID, + UserID: userID, + }) + if err != nil { + return false, fmt.Errorf("check chat membership: %w", mapError(err)) + } + + return member, nil +} + +func (r *AttachmentRepository) Create(ctx context.Context, draft domain.AttachmentDraft) (domain.Attachment, error) { + ctx, cancel := r.store.timeout(ctx) + defer cancel() + + row, err := r.store.queries.CreateAttachment(ctx, sqlcgen.CreateAttachmentParams{ + ID: draft.ID, + ChatID: draft.ChatID, + OwnerID: draft.OwnerID, + ObjectKey: draft.ObjectKey, + Filename: draft.Filename, + ContentType: draft.ContentType, + SizeBytes: draft.SizeBytes, + Sha256: draft.SHA256, + }) + if err != nil { + return domain.Attachment{}, fmt.Errorf("create attachment: %w", mapError(err)) + } + + return mapAttachment(row), nil +} + +func (r *AttachmentRepository) MarkReady( + ctx context.Context, + id uuid.UUID, + objectKey string, +) (domain.Attachment, error) { + ctx, cancel := r.store.timeout(ctx) + defer cancel() + + row, err := r.store.queries.MarkAttachmentReady(ctx, sqlcgen.MarkAttachmentReadyParams{ + ID: id, + ObjectKey: objectKey, + }) + if err != nil { + return domain.Attachment{}, fmt.Errorf("mark attachment ready: %w", mapError(err)) + } + + return mapAttachment(row), nil +} + +func (r *AttachmentRepository) DeletePending(ctx context.Context, id uuid.UUID) error { + ctx, cancel := r.store.timeout(ctx) + defer cancel() + + if err := r.store.queries.DeletePendingAttachment(ctx, id); err != nil { + return fmt.Errorf("delete pending attachment: %w", mapError(err)) + } + + return nil +} + +func (r *AttachmentRepository) GetForMember( + ctx context.Context, + userID, id uuid.UUID, +) (domain.Attachment, error) { + ctx, cancel := r.store.timeout(ctx) + defer cancel() + + row, err := r.store.queries.GetAttachmentForMember(ctx, sqlcgen.GetAttachmentForMemberParams{ + ID: id, + UserID: userID, + }) + if err != nil { + return domain.Attachment{}, fmt.Errorf("get attachment for member: %w", mapError(err)) + } + + return mapAttachment(row), nil +} + +func (r *AttachmentRepository) GetForOwner( + ctx context.Context, + ownerID, id uuid.UUID, +) (domain.Attachment, error) { + ctx, cancel := r.store.timeout(ctx) + defer cancel() + + row, err := r.store.queries.GetAttachmentForOwner(ctx, sqlcgen.GetAttachmentForOwnerParams{ + ID: id, + OwnerID: ownerID, + }) + if err != nil { + return domain.Attachment{}, fmt.Errorf("get attachment for owner: %w", mapError(err)) + } + + return mapAttachment(row), nil +} + +func (r *AttachmentRepository) ListStates( + ctx context.Context, + chatID uuid.UUID, + ids []uuid.UUID, +) ([]domain.AttachmentState, error) { + ctx, cancel := r.store.timeout(ctx) + defer cancel() + + rows, err := r.store.queries.ListAttachmentStatesForChat(ctx, sqlcgen.ListAttachmentStatesForChatParams{ + ChatID: chatID, + Ids: ids, + }) + if err != nil { + return nil, fmt.Errorf("list attachment states: %w", mapError(err)) + } + + states := make([]domain.AttachmentState, 0, len(rows)) + for _, row := range rows { + states = append(states, domain.AttachmentState{ + ID: row.ID, + Status: domain.AttachmentStatus(row.Status), + }) + } + + return states, nil +} + +func (r *AttachmentRepository) ListStalePending( + ctx context.Context, + createdBefore time.Time, + limit int32, +) ([]domain.Attachment, error) { + ctx, cancel := r.store.timeout(ctx) + defer cancel() + + rows, err := r.store.queries.ListStalePendingAttachments(ctx, sqlcgen.ListStalePendingAttachmentsParams{ + CreatedBefore: createdBefore, + RowLimit: limit, + }) + if err != nil { + return nil, fmt.Errorf("list stale attachments: %w", mapError(err)) + } + + return mapAll(rows, mapAttachment), nil +} + +func (r *AttachmentRepository) ListKeys( + ctx context.Context, + limit, offset int32, +) ([]domain.AttachmentKey, error) { + ctx, cancel := r.store.timeout(ctx) + defer cancel() + + rows, err := r.store.queries.ListAttachmentKeys(ctx, sqlcgen.ListAttachmentKeysParams{ + RowLimit: limit, + RowOffset: offset, + }) + if err != nil { + return nil, fmt.Errorf("list attachment keys: %w", mapError(err)) + } + + keys := make([]domain.AttachmentKey, 0, len(rows)) + for _, row := range rows { + keys = append(keys, domain.AttachmentKey{ + ID: row.ID, + ObjectKey: row.ObjectKey, + Status: domain.AttachmentStatus(row.Status), + CreatedAt: toUTCTime(row.CreatedAt), + }) + } + + return keys, nil +} + +func mapAttachment(row sqlcgen.Attachment) domain.Attachment { + attachment := domain.Attachment{ + ID: row.ID, + ChatID: row.ChatID, + OwnerID: row.OwnerID, + ObjectKey: row.ObjectKey, + Filename: row.Filename, + ContentType: row.ContentType, + SizeBytes: row.SizeBytes, + SHA256: row.Sha256, + Status: domain.AttachmentStatus(row.Status), + CreatedAt: toUTCTime(row.CreatedAt), + UpdatedAt: toUTCTime(row.UpdatedAt), + } + + if row.ErrorCode.Valid { + code := row.ErrorCode.String + attachment.ErrorCode = &code + } + + return attachment +} diff --git a/internal/storage/postgres/attachment_repository_test.go b/internal/storage/postgres/attachment_repository_test.go new file mode 100644 index 00000000..98bac411 --- /dev/null +++ b/internal/storage/postgres/attachment_repository_test.go @@ -0,0 +1,92 @@ +//go:build integration + +package postgres_test + +import ( + "strings" + "testing" + + "github.com/google/uuid" + "github.com/stretchr/testify/suite" + + "mtusi-messenger/internal/domain" +) + +type AttachmentRepositorySuite struct { + BaseSuite +} + +func TestAttachmentRepositorySuite(t *testing.T) { + suite.Run(t, new(AttachmentRepositorySuite)) +} + +func (s *AttachmentRepositorySuite) TestLifecycleAndMessageLinks() { + alice := s.createUser("alice") + bob := s.createUser("bob") + eve := s.createUser("eve") + chat := s.createChat(alice, bob) + + id, err := uuid.NewV7() + s.Require().NoError(err) + + objectKey := "attachments/" + chat.ID.String() + "/" + id.String() + digest := strings.Repeat("a", 64) + + created, err := s.store.Attachments().Create(s.T().Context(), domain.AttachmentDraft{ + ID: id, + ChatID: chat.ID, + OwnerID: alice.ID, + ObjectKey: objectKey, + Filename: "photo.png", + ContentType: "image/png", + SizeBytes: 123, + SHA256: digest, + }) + s.Require().NoError(err) + s.Equal(domain.AttachmentPending, created.Status) + + visible, err := s.store.Attachments().GetForMember(s.T().Context(), bob.ID, id) + s.Require().NoError(err) + s.Equal(alice.ID, visible.OwnerID) + + _, err = s.store.Attachments().GetForMember(s.T().Context(), eve.ID, id) + s.Require().ErrorIs(err, domain.ErrNotFound) + + ready, err := s.store.Attachments().MarkReady(s.T().Context(), id, objectKey) + s.Require().NoError(err) + s.Equal(domain.AttachmentReady, ready.Status) + + states, err := s.store.Attachments().ListStates( + s.T().Context(), chat.ID, []uuid.UUID{id}, + ) + s.Require().NoError(err) + s.Require().Len(states, 1) + s.Equal(domain.AttachmentReady, states[0].Status) + + key := uuid.NewString() + draft := domain.MessageDraft{ + ChatID: chat.ID, + SenderID: alice.ID, + Text: "", + AttachmentIDs: []uuid.UUID{id}, + Idempotency: domain.MessageIdempotency{ + Key: key, + RequestHash: [32]byte{1}, + }, + } + + message, err := s.store.Messages().Create(s.T().Context(), draft) + s.Require().NoError(err) + s.Equal([]uuid.UUID{id}, message.AttachmentIDs) + + page, err := s.store.Messages().ListVisible(s.T().Context(), chat.ID, bob.ID, nil, 50) + s.Require().NoError(err) + s.Require().Len(page.Items, 1) + s.Equal([]uuid.UUID{id}, page.Items[0].AttachmentIDs) + s.Empty(page.Items[0].Text) + + replayed, err := s.store.Messages().Create(s.T().Context(), draft) + s.Require().NoError(err) + s.Equal(message.ID, replayed.ID) + s.Equal([]uuid.UUID{id}, replayed.AttachmentIDs) +} diff --git a/internal/storage/postgres/internal/sqlcgen/attachments.sql.go b/internal/storage/postgres/internal/sqlcgen/attachments.sql.go new file mode 100644 index 00000000..e7dfbac2 --- /dev/null +++ b/internal/storage/postgres/internal/sqlcgen/attachments.sql.go @@ -0,0 +1,367 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 +// source: attachments.sql + +package sqlcgen + +import ( + "context" + "time" + + "github.com/google/uuid" +) + +const attachToMessage = `-- name: AttachToMessage :exec +INSERT INTO message_attachments (message_id, attachment_id, position) +VALUES ($1, $2, $3) +` + +type AttachToMessageParams struct { + MessageID uuid.UUID + AttachmentID uuid.UUID + Position int16 +} + +func (q *Queries) AttachToMessage(ctx context.Context, arg AttachToMessageParams) error { + _, err := q.db.Exec(ctx, attachToMessage, arg.MessageID, arg.AttachmentID, arg.Position) + return err +} + +const createAttachment = `-- name: CreateAttachment :one +INSERT INTO attachments ( + id, chat_id, owner_id, object_key, filename, content_type, size_bytes, sha256, status +) +VALUES ( + $1, + $2, + $3, + $4, + $5, + $6, + $7, + $8, + 'pending' +) +RETURNING id, chat_id, owner_id, object_key, filename, content_type, size_bytes, sha256, + status, error_code, created_at, updated_at +` + +type CreateAttachmentParams struct { + ID uuid.UUID + ChatID uuid.UUID + OwnerID uuid.UUID + ObjectKey string + Filename string + ContentType string + SizeBytes int64 + Sha256 string +} + +func (q *Queries) CreateAttachment(ctx context.Context, arg CreateAttachmentParams) (Attachment, error) { + row := q.db.QueryRow(ctx, createAttachment, + arg.ID, + arg.ChatID, + arg.OwnerID, + arg.ObjectKey, + arg.Filename, + arg.ContentType, + arg.SizeBytes, + arg.Sha256, + ) + var i Attachment + err := row.Scan( + &i.ID, + &i.ChatID, + &i.OwnerID, + &i.ObjectKey, + &i.Filename, + &i.ContentType, + &i.SizeBytes, + &i.Sha256, + &i.Status, + &i.ErrorCode, + &i.CreatedAt, + &i.UpdatedAt, + ) + return i, err +} + +const deletePendingAttachment = `-- name: DeletePendingAttachment :exec +DELETE FROM attachments +WHERE id = $1 + AND status = 'pending' +` + +func (q *Queries) DeletePendingAttachment(ctx context.Context, id uuid.UUID) error { + _, err := q.db.Exec(ctx, deletePendingAttachment, id) + return err +} + +const getAttachmentForMember = `-- name: GetAttachmentForMember :one +SELECT a.id, a.chat_id, a.owner_id, a.object_key, a.filename, a.content_type, + a.size_bytes, a.sha256, a.status, a.error_code, a.created_at, a.updated_at +FROM attachments a +JOIN chat_members cm + ON cm.chat_id = a.chat_id + AND cm.user_id = $1 +WHERE a.id = $2 +` + +type GetAttachmentForMemberParams struct { + UserID uuid.UUID + ID uuid.UUID +} + +func (q *Queries) GetAttachmentForMember(ctx context.Context, arg GetAttachmentForMemberParams) (Attachment, error) { + row := q.db.QueryRow(ctx, getAttachmentForMember, arg.UserID, arg.ID) + var i Attachment + err := row.Scan( + &i.ID, + &i.ChatID, + &i.OwnerID, + &i.ObjectKey, + &i.Filename, + &i.ContentType, + &i.SizeBytes, + &i.Sha256, + &i.Status, + &i.ErrorCode, + &i.CreatedAt, + &i.UpdatedAt, + ) + return i, err +} + +const getAttachmentForOwner = `-- name: GetAttachmentForOwner :one +SELECT a.id, a.chat_id, a.owner_id, a.object_key, a.filename, a.content_type, + a.size_bytes, a.sha256, a.status, a.error_code, a.created_at, a.updated_at +FROM attachments a +JOIN chat_members cm + ON cm.chat_id = a.chat_id + AND cm.user_id = a.owner_id +WHERE a.id = $1 + AND a.owner_id = $2 +` + +type GetAttachmentForOwnerParams struct { + ID uuid.UUID + OwnerID uuid.UUID +} + +func (q *Queries) GetAttachmentForOwner(ctx context.Context, arg GetAttachmentForOwnerParams) (Attachment, error) { + row := q.db.QueryRow(ctx, getAttachmentForOwner, arg.ID, arg.OwnerID) + var i Attachment + err := row.Scan( + &i.ID, + &i.ChatID, + &i.OwnerID, + &i.ObjectKey, + &i.Filename, + &i.ContentType, + &i.SizeBytes, + &i.Sha256, + &i.Status, + &i.ErrorCode, + &i.CreatedAt, + &i.UpdatedAt, + ) + return i, err +} + +const listAttachmentKeys = `-- name: ListAttachmentKeys :many +SELECT id, object_key, status, created_at +FROM attachments +ORDER BY id +LIMIT $2 OFFSET $1 +` + +type ListAttachmentKeysParams struct { + RowOffset int32 + RowLimit int32 +} + +type ListAttachmentKeysRow struct { + ID uuid.UUID + ObjectKey string + Status string + CreatedAt time.Time +} + +func (q *Queries) ListAttachmentKeys(ctx context.Context, arg ListAttachmentKeysParams) ([]ListAttachmentKeysRow, error) { + rows, err := q.db.Query(ctx, listAttachmentKeys, arg.RowOffset, arg.RowLimit) + if err != nil { + return nil, err + } + defer rows.Close() + items := []ListAttachmentKeysRow{} + for rows.Next() { + var i ListAttachmentKeysRow + if err := rows.Scan( + &i.ID, + &i.ObjectKey, + &i.Status, + &i.CreatedAt, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const listAttachmentStatesForChat = `-- name: ListAttachmentStatesForChat :many +SELECT id, status +FROM attachments +WHERE chat_id = $1 + AND id = ANY($2::uuid[]) +` + +type ListAttachmentStatesForChatParams struct { + ChatID uuid.UUID + Ids []uuid.UUID +} + +type ListAttachmentStatesForChatRow struct { + ID uuid.UUID + Status string +} + +func (q *Queries) ListAttachmentStatesForChat(ctx context.Context, arg ListAttachmentStatesForChatParams) ([]ListAttachmentStatesForChatRow, error) { + rows, err := q.db.Query(ctx, listAttachmentStatesForChat, arg.ChatID, arg.Ids) + if err != nil { + return nil, err + } + defer rows.Close() + items := []ListAttachmentStatesForChatRow{} + for rows.Next() { + var i ListAttachmentStatesForChatRow + if err := rows.Scan(&i.ID, &i.Status); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const listMessageAttachments = `-- name: ListMessageAttachments :many +SELECT message_id, attachment_id +FROM message_attachments +WHERE message_id = ANY($1::uuid[]) +ORDER BY message_id, position +` + +type ListMessageAttachmentsRow struct { + MessageID uuid.UUID + AttachmentID uuid.UUID +} + +func (q *Queries) ListMessageAttachments(ctx context.Context, messageIds []uuid.UUID) ([]ListMessageAttachmentsRow, error) { + rows, err := q.db.Query(ctx, listMessageAttachments, messageIds) + if err != nil { + return nil, err + } + defer rows.Close() + items := []ListMessageAttachmentsRow{} + for rows.Next() { + var i ListMessageAttachmentsRow + if err := rows.Scan(&i.MessageID, &i.AttachmentID); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const listStalePendingAttachments = `-- name: ListStalePendingAttachments :many +SELECT id, chat_id, owner_id, object_key, filename, content_type, size_bytes, sha256, + status, error_code, created_at, updated_at +FROM attachments +WHERE status = 'pending' + AND created_at < $1 +ORDER BY created_at +LIMIT $2 +` + +type ListStalePendingAttachmentsParams struct { + CreatedBefore time.Time + RowLimit int32 +} + +func (q *Queries) ListStalePendingAttachments(ctx context.Context, arg ListStalePendingAttachmentsParams) ([]Attachment, error) { + rows, err := q.db.Query(ctx, listStalePendingAttachments, arg.CreatedBefore, arg.RowLimit) + if err != nil { + return nil, err + } + defer rows.Close() + items := []Attachment{} + for rows.Next() { + var i Attachment + if err := rows.Scan( + &i.ID, + &i.ChatID, + &i.OwnerID, + &i.ObjectKey, + &i.Filename, + &i.ContentType, + &i.SizeBytes, + &i.Sha256, + &i.Status, + &i.ErrorCode, + &i.CreatedAt, + &i.UpdatedAt, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const markAttachmentReady = `-- name: MarkAttachmentReady :one +UPDATE attachments +SET status = 'ready', + object_key = $1, + updated_at = now() +WHERE id = $2 + AND status = 'pending' +RETURNING id, chat_id, owner_id, object_key, filename, content_type, size_bytes, sha256, + status, error_code, created_at, updated_at +` + +type MarkAttachmentReadyParams struct { + ObjectKey string + ID uuid.UUID +} + +func (q *Queries) MarkAttachmentReady(ctx context.Context, arg MarkAttachmentReadyParams) (Attachment, error) { + row := q.db.QueryRow(ctx, markAttachmentReady, arg.ObjectKey, arg.ID) + var i Attachment + err := row.Scan( + &i.ID, + &i.ChatID, + &i.OwnerID, + &i.ObjectKey, + &i.Filename, + &i.ContentType, + &i.SizeBytes, + &i.Sha256, + &i.Status, + &i.ErrorCode, + &i.CreatedAt, + &i.UpdatedAt, + ) + return i, err +} diff --git a/internal/storage/postgres/internal/sqlcgen/models.go b/internal/storage/postgres/internal/sqlcgen/models.go index d9f11089..9f5a2647 100644 --- a/internal/storage/postgres/internal/sqlcgen/models.go +++ b/internal/storage/postgres/internal/sqlcgen/models.go @@ -11,6 +11,21 @@ import ( "github.com/jackc/pgx/v5/pgtype" ) +type Attachment struct { + ID uuid.UUID + ChatID uuid.UUID + OwnerID uuid.UUID + ObjectKey string + Filename string + ContentType string + SizeBytes int64 + Sha256 string + Status string + ErrorCode pgtype.Text + CreatedAt time.Time + UpdatedAt time.Time +} + type Chat struct { ID uuid.UUID Title string @@ -31,6 +46,12 @@ type Message struct { CreatedAt time.Time } +type MessageAttachment struct { + MessageID uuid.UUID + AttachmentID uuid.UUID + Position int16 +} + type MessageIdempotency struct { ActorID uuid.UUID ChatID uuid.UUID diff --git a/internal/storage/postgres/message_repository.go b/internal/storage/postgres/message_repository.go index c2744823..84ee5640 100644 --- a/internal/storage/postgres/message_repository.go +++ b/internal/storage/postgres/message_repository.go @@ -19,6 +19,21 @@ type MessageRepository struct { store *Store } +func (r *MessageRepository) IsChatMember(ctx context.Context, chatID, userID uuid.UUID) (bool, error) { + ctx, cancel := r.store.timeout(ctx) + defer cancel() + + member, err := r.store.queries.IsChatMember(ctx, sqlcgen.IsChatMemberParams{ + ChatID: chatID, + UserID: userID, + }) + if err != nil { + return false, fmt.Errorf("check chat membership: %w", mapError(err)) + } + + return member, nil +} + func (r *MessageRepository) Create(ctx context.Context, draft domain.MessageDraft) (domain.Message, error) { var created domain.Message @@ -80,6 +95,16 @@ func createClaimed(ctx context.Context, queries *sqlcgen.Queries, draft domain.M return domain.Message{}, mapError(err) } + for position, attachmentID := range draft.AttachmentIDs { + if err := queries.AttachToMessage(ctx, sqlcgen.AttachToMessageParams{ + MessageID: row.ID, + AttachmentID: attachmentID, + Position: int16(position), + }); err != nil { + return domain.Message{}, mapError(err) + } + } + err = queries.CompleteMessageIdempotency(ctx, sqlcgen.CompleteMessageIdempotencyParams{ MessageID: pgtype.UUID{Bytes: row.ID, Valid: true}, ActorID: draft.SenderID, @@ -90,7 +115,11 @@ func createClaimed(ctx context.Context, queries *sqlcgen.Queries, draft domain.M return domain.Message{}, mapError(err) } - return mapMessage(row.ID, row.ChatID, row.SenderID, row.Text, row.CreatedAt), nil + created := mapMessage(row.ID, row.ChatID, row.SenderID, row.Text, row.CreatedAt) + created.AttachmentIDs = make([]uuid.UUID, 0, len(draft.AttachmentIDs)) + created.AttachmentIDs = append(created.AttachmentIDs, draft.AttachmentIDs...) + + return created, nil } func replayIdempotent(ctx context.Context, queries *sqlcgen.Queries, draft domain.MessageDraft) (domain.Message, error) { @@ -116,7 +145,34 @@ func replayIdempotent(ctx context.Context, queries *sqlcgen.Queries, draft domai return domain.Message{}, mapError(err) } - return mapMessage(row.ID, row.ChatID, row.SenderID, row.Text, row.CreatedAt), nil + replayed := mapMessage(row.ID, row.ChatID, row.SenderID, row.Text, row.CreatedAt) + replayed.AttachmentIDs, err = listAttachmentIDs(ctx, queries, row.ID) + if err != nil { + return domain.Message{}, err + } + + return replayed, nil +} + +// listAttachmentIDs returns attachment IDs in the order the sender supplied +// them. An empty result is normalised to an empty slice, never nil: the +// contract marks attachment_ids as required. +func listAttachmentIDs( + ctx context.Context, + queries *sqlcgen.Queries, + messageID uuid.UUID, +) ([]uuid.UUID, error) { + rows, err := queries.ListMessageAttachments(ctx, []uuid.UUID{messageID}) + if err != nil { + return nil, fmt.Errorf("list message attachments: %w", mapError(err)) + } + + ids := make([]uuid.UUID, 0, len(rows)) + for _, row := range rows { + ids = append(ids, row.AttachmentID) + } + + return ids, nil } func (r *MessageRepository) ListVisible( @@ -164,6 +220,8 @@ func (r *MessageRepository) fetch( after *domain.Cursor, fetch int32, ) ([]domain.Message, error) { + var messages []domain.Message + if after == nil { rows, err := r.store.queries.ListMessagesForChat(ctx, sqlcgen.ListMessagesForChatParams{ ChatID: chatID, @@ -174,21 +232,63 @@ func (r *MessageRepository) fetch( return nil, fmt.Errorf("list messages: %w", mapError(err)) } - return mapAll(rows, mapMessageRow), nil + messages = mapAll(rows, mapMessageRow) + } else { + rows, err := r.store.queries.ListMessagesForChatAfter(ctx, sqlcgen.ListMessagesForChatAfterParams{ + ChatID: chatID, + CallerID: callerID, + AfterCreatedAt: after.CreatedAt, + AfterID: after.ID, + RowLimit: fetch, + }) + if err != nil { + return nil, fmt.Errorf("list messages: %w", mapError(err)) + } + + messages = mapAll(rows, mapMessageRow) } - rows, err := r.store.queries.ListMessagesForChatAfter(ctx, sqlcgen.ListMessagesForChatAfterParams{ - ChatID: chatID, - CallerID: callerID, - AfterCreatedAt: after.CreatedAt, - AfterID: after.ID, - RowLimit: fetch, - }) + if err := attachMessageLinks(ctx, r.store.queries, messages); err != nil { + return nil, err + } + + return messages, nil +} + +// attachMessageLinks fetches all links for a page in one query and normalises +// absent lists to empty slices. +func attachMessageLinks( + ctx context.Context, + queries *sqlcgen.Queries, + messages []domain.Message, +) error { + if len(messages) == 0 { + return nil + } + + ids := make([]uuid.UUID, 0, len(messages)) + for index := range messages { + ids = append(ids, messages[index].ID) + messages[index].AttachmentIDs = []uuid.UUID{} + } + + rows, err := queries.ListMessageAttachments(ctx, ids) if err != nil { - return nil, fmt.Errorf("list messages: %w", mapError(err)) + return fmt.Errorf("list message attachments: %w", mapError(err)) } - return mapAll(rows, mapMessageRow), nil + byMessage := make(map[uuid.UUID][]uuid.UUID, len(messages)) + for _, row := range rows { + byMessage[row.MessageID] = append(byMessage[row.MessageID], row.AttachmentID) + } + + for index := range messages { + if linked, ok := byMessage[messages[index].ID]; ok { + messages[index].AttachmentIDs = linked + } + } + + return nil } func mapMessageRow(row sqlcgen.Message) domain.Message { diff --git a/internal/storage/postgres/migrations/00004_attachments.sql b/internal/storage/postgres/migrations/00004_attachments.sql new file mode 100644 index 00000000..96fcbdc8 --- /dev/null +++ b/internal/storage/postgres/migrations/00004_attachments.sql @@ -0,0 +1,55 @@ +-- +goose Up +-- Attachment metadata lives in PostgreSQL; the original bytes live only in S3. +CREATE TABLE attachments ( + id uuid PRIMARY KEY, + chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE, + owner_id uuid NOT NULL REFERENCES users (id) ON DELETE RESTRICT, + object_key text NOT NULL, + filename text NOT NULL, + content_type text NOT NULL, + size_bytes bigint NOT NULL, + sha256 text NOT NULL, + status text NOT NULL, + error_code text, + created_at timestamptz NOT NULL DEFAULT now(), + updated_at timestamptz NOT NULL DEFAULT now(), + + CONSTRAINT attachments_object_key_key UNIQUE (object_key), + CONSTRAINT attachments_status_check CHECK (status IN ('pending', 'ready', 'failed')), + CONSTRAINT attachments_content_type_check CHECK (content_type IN ('image/png', 'image/jpeg')), + CONSTRAINT attachments_filename_length CHECK (char_length(filename) BETWEEN 1 AND 255), + CONSTRAINT attachments_size_check CHECK (size_bytes BETWEEN 1 AND 10485760), + CONSTRAINT attachments_sha256_check CHECK (sha256 ~ '^[0-9a-f]{64}$'), + CONSTRAINT attachments_error_consistency CHECK ( + (status = 'ready' AND error_code IS NULL) OR + (status = 'failed' AND error_code IS NOT NULL) OR + status = 'pending' + ) +); + +CREATE INDEX attachments_chat_id_created_at_id_idx ON attachments (chat_id, created_at, id); +CREATE INDEX attachments_status_created_at_idx ON attachments (status, created_at); + +CREATE TABLE message_attachments ( + message_id uuid NOT NULL REFERENCES messages (id) ON DELETE CASCADE, + attachment_id uuid NOT NULL REFERENCES attachments (id) ON DELETE RESTRICT, + position smallint NOT NULL, + + PRIMARY KEY (message_id, attachment_id), + CONSTRAINT message_attachments_position_check CHECK (position BETWEEN 0 AND 9), + CONSTRAINT message_attachments_position_key UNIQUE (message_id, position) +); + +CREATE INDEX message_attachments_attachment_id_idx ON message_attachments (attachment_id); + +-- Lab1-3 messages must stay valid. Attachment-only messages use text = ''; +-- the "text OR attachment" rule is enforced by the service and ogen. +ALTER TABLE messages DROP CONSTRAINT messages_text_not_blank; + +-- +goose Down +-- WARNING: fails if attachment-only messages already exist. Roll back such +-- rows or the constraint cannot be restored. +ALTER TABLE messages ADD CONSTRAINT messages_text_not_blank CHECK (btrim(text) <> ''); + +DROP TABLE message_attachments; +DROP TABLE attachments; diff --git a/internal/storage/postgres/queries/attachments.sql b/internal/storage/postgres/queries/attachments.sql new file mode 100644 index 00000000..830468aa --- /dev/null +++ b/internal/storage/postgres/queries/attachments.sql @@ -0,0 +1,82 @@ +-- name: CreateAttachment :one +INSERT INTO attachments ( + id, chat_id, owner_id, object_key, filename, content_type, size_bytes, sha256, status +) +VALUES ( + sqlc.arg(id), + sqlc.arg(chat_id), + sqlc.arg(owner_id), + sqlc.arg(object_key), + sqlc.arg(filename), + sqlc.arg(content_type), + sqlc.arg(size_bytes), + sqlc.arg(sha256), + 'pending' +) +RETURNING id, chat_id, owner_id, object_key, filename, content_type, size_bytes, sha256, + status, error_code, created_at, updated_at; + +-- name: MarkAttachmentReady :one +UPDATE attachments +SET status = 'ready', + object_key = sqlc.arg(object_key), + updated_at = now() +WHERE id = sqlc.arg(id) + AND status = 'pending' +RETURNING id, chat_id, owner_id, object_key, filename, content_type, size_bytes, sha256, + status, error_code, created_at, updated_at; + +-- name: GetAttachmentForMember :one +SELECT a.id, a.chat_id, a.owner_id, a.object_key, a.filename, a.content_type, + a.size_bytes, a.sha256, a.status, a.error_code, a.created_at, a.updated_at +FROM attachments a +JOIN chat_members cm + ON cm.chat_id = a.chat_id + AND cm.user_id = sqlc.arg(user_id) +WHERE a.id = sqlc.arg(id); + +-- name: GetAttachmentForOwner :one +SELECT a.id, a.chat_id, a.owner_id, a.object_key, a.filename, a.content_type, + a.size_bytes, a.sha256, a.status, a.error_code, a.created_at, a.updated_at +FROM attachments a +JOIN chat_members cm + ON cm.chat_id = a.chat_id + AND cm.user_id = a.owner_id +WHERE a.id = sqlc.arg(id) + AND a.owner_id = sqlc.arg(owner_id); + +-- name: ListAttachmentStatesForChat :many +SELECT id, status +FROM attachments +WHERE chat_id = sqlc.arg(chat_id) + AND id = ANY(sqlc.arg(ids)::uuid[]); + +-- name: AttachToMessage :exec +INSERT INTO message_attachments (message_id, attachment_id, position) +VALUES (sqlc.arg(message_id), sqlc.arg(attachment_id), sqlc.arg(position)); + +-- name: ListMessageAttachments :many +SELECT message_id, attachment_id +FROM message_attachments +WHERE message_id = ANY(sqlc.arg(message_ids)::uuid[]) +ORDER BY message_id, position; + +-- name: DeletePendingAttachment :exec +DELETE FROM attachments +WHERE id = sqlc.arg(id) + AND status = 'pending'; + +-- name: ListStalePendingAttachments :many +SELECT id, chat_id, owner_id, object_key, filename, content_type, size_bytes, sha256, + status, error_code, created_at, updated_at +FROM attachments +WHERE status = 'pending' + AND created_at < sqlc.arg(created_before) +ORDER BY created_at +LIMIT sqlc.arg(row_limit); + +-- name: ListAttachmentKeys :many +SELECT id, object_key, status, created_at +FROM attachments +ORDER BY id +LIMIT sqlc.arg(row_limit) OFFSET sqlc.arg(row_offset); diff --git a/internal/storage/postgres/store.go b/internal/storage/postgres/store.go index 35aff1ea..f0313f78 100644 --- a/internal/storage/postgres/store.go +++ b/internal/storage/postgres/store.go @@ -17,10 +17,11 @@ type Store struct { queryTimeout time.Duration idempotencyTTL time.Duration - users *UserRepository - chats *ChatRepository - messages *MessageRepository - sessions *SessionRepository + users *UserRepository + chats *ChatRepository + messages *MessageRepository + sessions *SessionRepository + attachments *AttachmentRepository } func New(ctx context.Context, cfg config.Postgres, idempotencyTTL time.Duration) (*Store, error) { @@ -65,6 +66,7 @@ func New(ctx context.Context, cfg config.Postgres, idempotencyTTL time.Duration) store.chats = &ChatRepository{store: store} store.messages = &MessageRepository{store: store} store.sessions = &SessionRepository{store: store} + store.attachments = &AttachmentRepository{store: store} return store, nil } @@ -77,6 +79,8 @@ func (s *Store) Messages() *MessageRepository { return s.messages } func (s *Store) Sessions() *SessionRepository { return s.sessions } +func (s *Store) Attachments() *AttachmentRepository { return s.attachments } + func (s *Store) Ping(ctx context.Context) error { if err := s.pool.Ping(ctx); err != nil { return fmt.Errorf("ping database: %w", err) @@ -87,6 +91,43 @@ func (s *Store) Ping(ctx context.Context) error { func (s *Store) Close() { s.pool.Close() } +// sweepLockKey is a process-independent constant: every replica contends for the +// same PostgreSQL session lock, so only one sweeper runs at a time. +const sweepLockKey int64 = 0x4c414234 // "LAB4" + +// AcquireSweepLock holds a session-level advisory lock on a dedicated +// connection. The returned release function must be called on that same +// connection before it is returned to the pool. +func (s *Store) AcquireSweepLock(ctx context.Context) (func(), bool, error) { + conn, err := s.pool.Acquire(ctx) + if err != nil { + return nil, false, fmt.Errorf("acquire sweep connection: %w", err) + } + + var acquired bool + if err := conn.QueryRow(ctx, "SELECT pg_try_advisory_lock($1)", sweepLockKey).Scan(&acquired); err != nil { + conn.Release() + + return nil, false, fmt.Errorf("acquire sweep lock: %w", err) + } + + if !acquired { + conn.Release() + + return nil, false, nil + } + + release := func() { + unlockCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), 5*time.Second) + defer cancel() + + _, _ = conn.Exec(unlockCtx, "SELECT pg_advisory_unlock($1)", sweepLockKey) + conn.Release() + } + + return release, true, nil +} + func (s *Store) timeout(ctx context.Context) (context.Context, context.CancelFunc) { if s.queryTimeout <= 0 { return context.WithCancel(ctx) diff --git a/internal/transport/rest/attachments.go b/internal/transport/rest/attachments.go new file mode 100644 index 00000000..5a72a519 --- /dev/null +++ b/internal/transport/rest/attachments.go @@ -0,0 +1,147 @@ +package rest + +import ( + "context" + "fmt" + "io" + + "mtusi-messenger/internal/domain" + attachmentService "mtusi-messenger/internal/service/attachment" + "mtusi-messenger/internal/transport/rest/internal/oas" +) + +func (h *Handler) UploadAttachment( + ctx context.Context, + req oas.UploadAttachmentReq, + params oas.UploadAttachmentParams, +) (oas.UploadAttachmentRes, error) { + body, declared, err := uploadBody(req) + if err != nil { + return nil, err + } + + attachment, err := h.attachments.Upload(ctx, attachmentService.UploadInput{ + ChatID: params.ChatID, + OwnerID: caller(ctx), + Filename: params.Filename, + DeclaredContentType: declared, + Body: body, + }) + if err != nil { + return nil, err + } + + return &oas.AttachmentHeaders{ + XRequestID: oas.NewOptString(requestIDFromContext(ctx)), + Response: attachmentResponse(attachment), + }, nil +} + +func (h *Handler) GetAttachment( + ctx context.Context, + params oas.GetAttachmentParams, +) (oas.GetAttachmentRes, error) { + attachment, err := h.attachments.Get(ctx, caller(ctx), params.AttachmentID) + if err != nil { + return nil, err + } + + return &oas.AttachmentHeaders{ + XRequestID: oas.NewOptString(requestIDFromContext(ctx)), + Response: attachmentResponse(attachment), + }, nil +} + +func (h *Handler) DownloadAttachment( + ctx context.Context, + params oas.DownloadAttachmentParams, +) (oas.DownloadAttachmentRes, error) { + if variant, ok := params.Variant.Get(); ok && variant != oas.DownloadAttachmentVariantOriginal { + return nil, fmt.Errorf("%w: variant %q is not available", domain.ErrNotFound, variant) + } + + attachment, body, err := h.attachments.Open(ctx, caller(ctx), params.AttachmentID) + if err != nil { + return nil, err + } + + // The generated transport copies the body after the handler returns. Close + // the S3 stream when the client disconnects; closeOnEOF covers the normal + // path. + _ = context.AfterFunc(ctx, func() { _ = body.Close() }) + + requestID := oas.NewOptString(requestIDFromContext(ctx)) + reader := closeOnEOF{ReadCloser: body} + + switch attachment.ContentType { + case "image/png": + return &oas.DownloadAttachmentOKImagePNGHeaders{ + XRequestID: requestID, + Response: oas.DownloadAttachmentOKImagePNG{Data: reader}, + }, nil + case "image/jpeg": + return &oas.DownloadAttachmentOKImageJpegHeaders{ + XRequestID: requestID, + Response: oas.DownloadAttachmentOKImageJpeg{Data: reader}, + }, nil + default: + _ = body.Close() + + return nil, fmt.Errorf("%w: unexpected content type %q", domain.ErrUnavailable, attachment.ContentType) + } +} + +func uploadBody(req oas.UploadAttachmentReq) (io.Reader, string, error) { + switch typed := req.(type) { + case *oas.UploadAttachmentReqImagePNG: + return typed.Data, "image/png", nil + case *oas.UploadAttachmentReqImageJpeg: + return typed.Data, "image/jpeg", nil + default: + return nil, "", fmt.Errorf("%w: request body must be image/png or image/jpeg", domain.ErrUnsupportedMedia) + } +} + +func attachmentResponse(attachment domain.Attachment) oas.Attachment { + response := oas.Attachment{ + ID: attachment.ID, + ChatID: attachment.ChatID, + OwnerID: attachment.OwnerID, + Filename: attachment.Filename, + SizeBytes: int(attachment.SizeBytes), + SHA256: attachment.SHA256, + Status: oas.AttachmentStatusReady, + Variants: []oas.Variant{}, + ErrorCode: oas.NilString{Null: true}, + CreatedAt: attachment.CreatedAt, + UpdatedAt: attachment.UpdatedAt, + } + + switch attachment.ContentType { + case "image/png": + response.ContentType = oas.AttachmentContentTypeImagePNG + case "image/jpeg": + response.ContentType = oas.AttachmentContentTypeImageJpeg + default: + response.ContentType = oas.AttachmentContentType(attachment.ContentType) + } + + if attachment.ErrorCode != nil { + response.ErrorCode = oas.NilString{Value: *attachment.ErrorCode} + } + + return response +} + +type closeOnEOF struct { + io.ReadCloser +} + +func (r closeOnEOF) Read(p []byte) (int, error) { + n, err := r.ReadCloser.Read(p) + if err != nil { + _ = r.Close() + } + + return n, err +} diff --git a/internal/transport/rest/bodylimit.go b/internal/transport/rest/bodylimit.go index 660feefc..5c8f9898 100644 --- a/internal/transport/rest/bodylimit.go +++ b/internal/transport/rest/bodylimit.go @@ -3,22 +3,36 @@ package rest import ( "log/slog" "net/http" + "regexp" ) +// attachmentUploadPath matches POST /api/v1/chats/{chat_id}/attachments. The +// UUID syntax is not validated here; this middleware only selects a body limit, +// and the generated transport rejects malformed identifiers later. +var attachmentUploadPath = regexp.MustCompile(`^/api/v1/chats/[^/]+/attachments$`) + // bodyLimitMiddleware bounds the request body before it reaches the generated -// transport. Without it the JSON decoders read the whole body into memory before -// any schema check or authentication happens, so an oversized request to a public -// endpoint (for example POST /api/v1/users) could exhaust the replica's memory. -// -// The declared length is rejected early with 413; a client that lies about -// Content-Length is cut off by http.MaxBytesReader, which also makes the server -// close the connection instead of reading the rest. -func bodyLimitMiddleware(limit int64, log *slog.Logger, next http.Handler) http.Handler { - if limit <= 0 { +// transport. JSON endpoints keep the small default limit; the attachment upload +// gets its own larger limit. Without this split the 10 MiB upload would be +// rejected before the handler, and raising the global limit would let any +// public JSON endpoint read a 10 MiB body. +func bodyLimitMiddleware( + defaultLimit, uploadLimit int64, + log *slog.Logger, + next http.Handler, +) http.Handler { + if defaultLimit <= 0 && uploadLimit <= 0 { return next } return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + limit := limitForRequest(r, defaultLimit, uploadLimit) + if limit <= 0 { + next.ServeHTTP(w, r) + + return + } + if r.ContentLength > limit { logRejected(r.Context(), log, r, http.StatusRequestEntityTooLarge, nil) writeError(r.Context(), log, w, r, http.StatusRequestEntityTooLarge) @@ -33,3 +47,11 @@ func bodyLimitMiddleware(limit int64, log *slog.Logger, next http.Handler) http. next.ServeHTTP(w, r) }) } + +func limitForRequest(r *http.Request, defaultLimit, uploadLimit int64) int64 { + if r.Method == http.MethodPost && attachmentUploadPath.MatchString(r.URL.Path) { + return uploadLimit + } + + return defaultLimit +} diff --git a/internal/transport/rest/bodylimit_test.go b/internal/transport/rest/bodylimit_test.go new file mode 100644 index 00000000..b7ee3ffd --- /dev/null +++ b/internal/transport/rest/bodylimit_test.go @@ -0,0 +1,65 @@ +package rest + +import ( + "io" + "net/http" + "net/http/httptest" + "strings" + "testing" + + "github.com/stretchr/testify/require" +) + +func TestLimitForRequest(t *testing.T) { + const ( + defaultLimit = 1024 + uploadLimit = 10 << 20 + ) + + upload, err := http.NewRequestWithContext(t.Context(), http.MethodPost, "/api/v1/chats/11111111-1111-4111-8111-111111111111/attachments", nil) + require.NoError(t, err) + require.Equal(t, int64(uploadLimit), limitForRequest(upload, defaultLimit, uploadLimit)) + + messages, err := http.NewRequestWithContext(t.Context(), http.MethodPost, "/api/v1/chats/11111111-1111-4111-8111-111111111111/messages", nil) + require.NoError(t, err) + require.Equal(t, int64(defaultLimit), limitForRequest(messages, defaultLimit, uploadLimit)) + + presign, err := http.NewRequestWithContext(t.Context(), http.MethodPost, "/api/v1/chats/11111111-1111-4111-8111-111111111111/attachments/presign", nil) + require.NoError(t, err) + require.Equal(t, int64(defaultLimit), limitForRequest(presign, defaultLimit, uploadLimit)) +} + +func TestBodyLimitMiddlewareSelectsUploadLimit(t *testing.T) { + const ( + defaultLimit = 16 + uploadLimit = 64 + ) + + next := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + body, err := io.ReadAll(r.Body) + if err != nil { + http.Error(w, err.Error(), http.StatusBadRequest) + return + } + _, _ = w.Write(body) + }) + handler := bodyLimitMiddleware(defaultLimit, uploadLimit, nil, next) + + upload := httptest.NewRequestWithContext( + t.Context(), http.MethodPost, + "/api/v1/chats/11111111-1111-4111-8111-111111111111/attachments", + strings.NewReader(strings.Repeat("x", 32)), + ) + uploadRecorder := httptest.NewRecorder() + handler.ServeHTTP(uploadRecorder, upload) + require.Equal(t, http.StatusOK, uploadRecorder.Code) + + jsonRequest := httptest.NewRequestWithContext( + t.Context(), http.MethodPost, + "/api/v1/chats/11111111-1111-4111-8111-111111111111/messages", + strings.NewReader(strings.Repeat("x", 32)), + ) + jsonRecorder := httptest.NewRecorder() + handler.ServeHTTP(jsonRecorder, jsonRequest) + require.Equal(t, http.StatusRequestEntityTooLarge, jsonRecorder.Code) +} diff --git a/internal/transport/rest/errors.go b/internal/transport/rest/errors.go index 0f5c2033..53c7cb9b 100644 --- a/internal/transport/rest/errors.go +++ b/internal/transport/rest/errors.go @@ -53,12 +53,17 @@ func statusForDomainError(err error) int { return http.StatusNotFound case errors.Is(err, domain.ErrUsernameTaken), errors.Is(err, domain.ErrConflict), - errors.Is(err, domain.ErrIdempotency): + errors.Is(err, domain.ErrIdempotency), + errors.Is(err, domain.ErrIncomplete): return http.StatusConflict case errors.Is(err, domain.ErrValidation), errors.Is(err, domain.ErrUnknownMember), errors.Is(err, domain.ErrInvalidCursor): return http.StatusBadRequest + case errors.Is(err, domain.ErrTooLarge): + return http.StatusRequestEntityTooLarge + case errors.Is(err, domain.ErrUnsupportedMedia): + return http.StatusUnsupportedMediaType case errors.Is(err, domain.ErrUnavailable): return http.StatusServiceUnavailable default: diff --git a/internal/transport/rest/extensions.go b/internal/transport/rest/extensions.go new file mode 100644 index 00000000..5a08b789 --- /dev/null +++ b/internal/transport/rest/extensions.go @@ -0,0 +1,252 @@ +package rest + +import ( + "context" + "encoding/json" + "errors" + "fmt" + "io" + "log/slog" + "mime" + "net/http" + "strings" + "time" + + "github.com/google/uuid" + + "mtusi-messenger/internal/domain" +) + +// SessionResolver is implemented by session.Service. Only token resolution is +// needed here; the generated security handler keeps its own interface. +type SessionResolver interface { + Resolve(ctx context.Context, token string) (domain.User, error) +} + +// Extensions implements the optional presigned-upload endpoints. They are +// mounted outside the ogen server so the mandatory OpenAPI contract remains +// untouched. +type Extensions struct { + attachments AttachmentService + sessions SessionResolver + log *slog.Logger +} + +func NewExtensions( + attachments AttachmentService, + sessions SessionResolver, + log *slog.Logger, +) *Extensions { + return &Extensions{attachments: attachments, sessions: sessions, log: log} +} + +func (e *Extensions) Presign() http.Handler { + return e.route(http.MethodPost, "presign", e.presign) +} + +func (e *Extensions) Complete() http.Handler { + return e.route(http.MethodPost, "complete", e.complete) +} + +type extensionHandler func(http.ResponseWriter, *http.Request, uuid.UUID) error + +func (e *Extensions) route(method, operation string, handler extensionHandler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + started := time.Now() + writer := &statusWriter{ResponseWriter: w} + + if r.Method != method { + writer.Header().Set("Allow", method) + writeError(r.Context(), e.log, writer, r, http.StatusMethodNotAllowed) + + return + } + + userID, err := e.authenticate(r) + if err != nil { + e.fail(writer, r, err) + + return + } + + err = handler(writer, r, userID) + if err != nil { + e.fail(writer, r, err) + + return + } + + if e.log != nil { + e.log.InfoContext(r.Context(), "extension request handled", + slog.String("request_id", requestIDFromContext(r.Context())), + slog.String("operation", operation), + slog.String("method", r.Method), + slog.String("path", r.URL.Path), + slog.String("user_id", userID.String()), + slog.Int("status", writer.statusCode()), + slog.Duration("duration", time.Since(started)), + ) + } + }) +} + +func (e *Extensions) authenticate(r *http.Request) (uuid.UUID, error) { + header := r.Header.Get("Authorization") + const prefix = "Bearer " + + if !strings.HasPrefix(header, prefix) { + return uuid.Nil, fmt.Errorf("%w: bearer token is required", domain.ErrUnauthenticated) + } + + token := strings.TrimSpace(strings.TrimPrefix(header, prefix)) + if token == "" { + return uuid.Nil, fmt.Errorf("%w: bearer token is empty", domain.ErrUnauthenticated) + } + + user, err := e.sessions.Resolve(r.Context(), token) + if err != nil { + return uuid.Nil, fmt.Errorf("%w: %w", domain.ErrUnauthenticated, err) + } + + return user.ID, nil +} + +func (e *Extensions) presign(w http.ResponseWriter, r *http.Request, userID uuid.UUID) error { + chatID, err := uuid.Parse(r.PathValue("chat_id")) + if err != nil { + return fmt.Errorf("%w: chat_id is not a UUID", domain.ErrValidation) + } + + var request struct { + Filename string `json:"filename"` + ContentType string `json:"content_type"` + SizeBytes int64 `json:"size_bytes"` + SHA256 string `json:"sha256"` + } + if err := decodeJSON(r, &request); err != nil { + return err + } + + result, err := e.attachments.Presign(r.Context(), domain.PresignRequest{ + ChatID: chatID, + OwnerID: userID, + Filename: request.Filename, + ContentType: request.ContentType, + SizeBytes: request.SizeBytes, + SHA256: request.SHA256, + }) + if err != nil { + return err + } + + return writeJSON(w, http.StatusCreated, struct { + AttachmentID string `json:"attachment_id"` + Method string `json:"method"` + UploadURL string `json:"upload_url"` + ExpiresAt time.Time `json:"expires_at"` + SHA256 string `json:"sha256"` + SizeBytes int64 `json:"size_bytes"` + }{ + AttachmentID: result.AttachmentID.String(), + Method: http.MethodPut, + UploadURL: result.UploadURL, + ExpiresAt: result.ExpiresAt.UTC(), + SHA256: result.SHA256, + SizeBytes: result.SizeBytes, + }) +} + +func (e *Extensions) complete(w http.ResponseWriter, r *http.Request, userID uuid.UUID) error { + id, err := uuid.Parse(r.PathValue("attachment_id")) + if err != nil { + return fmt.Errorf("%w: attachment_id is not a UUID", domain.ErrValidation) + } + + var request struct { + SHA256 string `json:"sha256"` + } + if err := decodeJSON(r, &request); err != nil { + return err + } + + attachment, err := e.attachments.Complete(r.Context(), userID, id, request.SHA256) + if err != nil { + return err + } + + return writeJSON(w, http.StatusOK, attachmentResponse(attachment)) +} + +func decodeJSON(r *http.Request, target any) error { + mediaType, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil || mediaType != "application/json" { + return fmt.Errorf("%w: Content-Type must be application/json", domain.ErrUnsupportedMedia) + } + + decoder := json.NewDecoder(r.Body) + decoder.DisallowUnknownFields() + + if err := decoder.Decode(target); err != nil { + return fmt.Errorf("%w: decode JSON: %w", domain.ErrValidation, err) + } + + if err := decoder.Decode(&struct{}{}); !errors.Is(err, io.EOF) { + return fmt.Errorf("%w: trailing JSON data", domain.ErrValidation) + } + + return nil +} + +func (e *Extensions) fail(w http.ResponseWriter, r *http.Request, err error) { + status := statusForDomainError(err) + if status == http.StatusInternalServerError && e.log != nil { + e.log.ErrorContext(r.Context(), "extension request failed", + slog.String("request_id", requestIDFromContext(r.Context())), + slog.String("method", r.Method), + slog.String("path", r.URL.Path), + slog.Any("error", err), + ) + } + + writeError(r.Context(), e.log, w, r, status) +} + +func writeJSON(w http.ResponseWriter, status int, payload any) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(status) + + if err := json.NewEncoder(w).Encode(payload); err != nil { + return fmt.Errorf("write JSON response: %w", err) + } + + return nil +} + +type statusWriter struct { + http.ResponseWriter + status int +} + +func (w *statusWriter) WriteHeader(status int) { + if w.status == 0 { + w.status = status + } + + w.ResponseWriter.WriteHeader(status) +} + +func (w *statusWriter) Write(body []byte) (int, error) { + if w.status == 0 { + w.status = http.StatusOK + } + + return w.ResponseWriter.Write(body) +} + +func (w *statusWriter) statusCode() int { + if w.status == 0 { + return http.StatusOK + } + + return w.status +} diff --git a/internal/transport/rest/handler.go b/internal/transport/rest/handler.go index f437f306..a6493bf5 100644 --- a/internal/transport/rest/handler.go +++ b/internal/transport/rest/handler.go @@ -7,12 +7,15 @@ import ( "encoding/base64" "encoding/json" "fmt" + "io" "net/http" + "slices" "time" "github.com/google/uuid" "mtusi-messenger/internal/domain" + attachmentService "mtusi-messenger/internal/service/attachment" "mtusi-messenger/internal/transport/rest/internal/oas" ) @@ -51,14 +54,23 @@ type SessionService interface { Revoke(ctx context.Context, userID uuid.UUID, token string) error } +type AttachmentService interface { + Upload(ctx context.Context, input attachmentService.UploadInput) (domain.Attachment, error) + Get(ctx context.Context, callerID, id uuid.UUID) (domain.Attachment, error) + Open(ctx context.Context, callerID, id uuid.UUID) (domain.Attachment, io.ReadCloser, error) + Presign(ctx context.Context, request domain.PresignRequest) (domain.PresignResult, error) + Complete(ctx context.Context, ownerID, id uuid.UUID, sha256 string) (domain.Attachment, error) +} + type Handler struct { oas.UnimplementedHandler - users UserService - chats ChatService - messages MessageService - health HealthChecker - sessions SessionService + users UserService + chats ChatService + messages MessageService + attachments AttachmentService + health HealthChecker + sessions SessionService } var noCursor *domain.Cursor @@ -67,15 +79,17 @@ func NewHandler( users UserService, chats ChatService, messages MessageService, + attachments AttachmentService, health HealthChecker, sessions SessionService, ) *Handler { return &Handler{ - users: users, - chats: chats, - messages: messages, - health: health, - sessions: sessions, + users: users, + chats: chats, + messages: messages, + attachments: attachments, + health: health, + sessions: sessions, } } @@ -238,9 +252,10 @@ func (h *Handler) CreateMessage( } message, err := h.messages.Send(ctx, domain.MessageDraft{ - ChatID: params.ChatID, - SenderID: callerID, - Text: req.Text, + ChatID: params.ChatID, + SenderID: callerID, + Text: req.Text, + AttachmentIDs: req.AttachmentIds, Idempotency: domain.MessageIdempotency{ Key: params.IdempotencyKey, RequestHash: fingerprint, @@ -260,9 +275,16 @@ func (h *Handler) CreateMessage( // order of the client JSON cannot change the fingerprint, while a different // payload with the same Idempotency-Key can (contract 1.3.0). func messageFingerprint(req *oas.CreateMessage) ([sha256.Size]byte, error) { + ids := make([]uuid.UUID, 0, len(req.AttachmentIds)) + ids = append(ids, req.AttachmentIds...) + slices.SortFunc(ids, func(left, right uuid.UUID) int { + return bytes.Compare(left[:], right[:]) + }) + payload, err := json.Marshal(struct { - Text string `json:"text"` - }{Text: req.Text}) + Text string `json:"text"` + AttachmentIDs []uuid.UUID `json:"attachment_ids"` + }{Text: req.Text, AttachmentIDs: ids}) if err != nil { return [sha256.Size]byte{}, fmt.Errorf("encode message payload: %w", err) } @@ -396,11 +418,15 @@ func chatResponse(chat domain.Chat) oas.Chat { } func messageResponse(message domain.Message) oas.Message { + ids := make([]uuid.UUID, 0, len(message.AttachmentIDs)) + ids = append(ids, message.AttachmentIDs...) + return oas.Message{ - ID: message.ID, - ChatID: message.ChatID, - SenderID: message.SenderID, - Text: message.Text, - CreatedAt: message.CreatedAt, + ID: message.ID, + ChatID: message.ChatID, + SenderID: message.SenderID, + Text: message.Text, + AttachmentIds: ids, + CreatedAt: message.CreatedAt, } } diff --git a/internal/transport/rest/instance_test.go b/internal/transport/rest/instance_test.go index edd5f196..342f7ae9 100644 --- a/internal/transport/rest/instance_test.go +++ b/internal/transport/rest/instance_test.go @@ -67,7 +67,7 @@ func TestInstanceIDMiddleware(t *testing.T) { instanceIDMiddleware("api-1", test.handler).ServeHTTP( recorder, - httptest.NewRequest(http.MethodGet, "/api/v1/users/me", nil), + httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/api/v1/users/me", nil), ) assert.Equal(t, test.wantID, recorder.Header().Get(instanceIDHeader)) diff --git a/internal/transport/rest/internal/oas/oas_cfg_gen.go b/internal/transport/rest/internal/oas/oas_cfg_gen.go index 2c4ff69f..1f7348c0 100644 --- a/internal/transport/rest/internal/oas/oas_cfg_gen.go +++ b/internal/transport/rest/internal/oas/oas_cfg_gen.go @@ -13,6 +13,7 @@ import ( var regexMap = map[string]ogenregex.Regexp{ "^[A-Za-z0-9._:-]+$": ogenregex.MustCompile("^[A-Za-z0-9._:-]+$"), + "^[a-f0-9]{64}$": ogenregex.MustCompile("^[a-f0-9]{64}$"), "^[a-z0-9_]{3,32}$": ogenregex.MustCompile("^[a-z0-9_]{3,32}$"), } diff --git a/internal/transport/rest/internal/oas/oas_defaults_gen.go b/internal/transport/rest/internal/oas/oas_defaults_gen.go new file mode 100644 index 00000000..8fc31d1f --- /dev/null +++ b/internal/transport/rest/internal/oas/oas_defaults_gen.go @@ -0,0 +1,15 @@ +// Code generated by ogen, DO NOT EDIT. + +package oas + +import ( + "github.com/google/uuid" +) + +// setDefaults set default value of fields. +func (s *CreateMessage) setDefaults() { + { + var defaultVal0 []uuid.UUID + s.AttachmentIds = defaultVal0 + } +} diff --git a/internal/transport/rest/internal/oas/oas_handlers_gen.go b/internal/transport/rest/internal/oas/oas_handlers_gen.go index aee7b144..ba46ed0d 100644 --- a/internal/transport/rest/internal/oas/oas_handlers_gen.go +++ b/internal/transport/rest/internal/oas/oas_handlers_gen.go @@ -529,6 +529,266 @@ func (s *Server) handleCurrentUserRequest(args [0]string, argsEscaped bool, w ht } } +// handleDownloadAttachmentRequest handles downloadAttachment operation. +// +// Скачать байты через авторизованный API. +// +// GET /api/v1/attachments/{attachment_id}/content +func (s *Server) handleDownloadAttachmentRequest(args [1]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { + statusWriter := &codeRecorder{ResponseWriter: w} + w = statusWriter + ctx := r.Context() + + var ( + err error + opErrContext = ogenerrors.OperationContext{ + Name: DownloadAttachmentOperation, + ID: "downloadAttachment", + } + ) + { + type bitset = [1]uint8 + var satisfied bitset + { + sctx, ok, err := s.securityBearerAuth(ctx, DownloadAttachmentOperation, r) + if err != nil { + err = &ogenerrors.SecurityError{ + OperationContext: opErrContext, + Security: "BearerAuth", + Err: err, + } + defer recordError("Security:BearerAuth", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + if ok { + satisfied[0] |= 1 << 0 + ctx = sctx + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + err = &ogenerrors.SecurityError{ + OperationContext: opErrContext, + Err: ogenerrors.ErrSecurityRequirementIsNotSatisfied, + } + defer recordError("Security", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + } + params, err := decodeDownloadAttachmentParams(args, argsEscaped, r) + if err != nil { + err = &ogenerrors.DecodeParamsError{ + OperationContext: opErrContext, + Err: err, + } + defer recordError("DecodeParams", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + var rawBody []byte + + var response DownloadAttachmentRes + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: DownloadAttachmentOperation, + OperationSummary: "Скачать байты через авторизованный API", + OperationID: "downloadAttachment", + Body: nil, + RawBody: rawBody, + Params: middleware.Parameters{ + { + Name: "attachment_id", + In: "path", + }: params.AttachmentID, + { + Name: "variant", + In: "query", + }: params.Variant, + }, + Raw: r, + } + + type ( + Request = struct{} + Params = DownloadAttachmentParams + Response = DownloadAttachmentRes + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + unpackDownloadAttachmentParams, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.DownloadAttachment(ctx, params) + return response, err + }, + ) + } else { + response, err = s.h.DownloadAttachment(ctx, params) + } + if err != nil { + defer recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeDownloadAttachmentResponse(response, w); err != nil { + defer recordError("EncodeResponse", err) + if !errors.Is(err, ht.ErrInternalServerErrorResponse) { + s.cfg.ErrorHandler(ctx, w, r, err) + } + return + } +} + +// handleGetAttachmentRequest handles getAttachment operation. +// +// Метаданные вложения, доступ участникам чата. +// +// GET /api/v1/attachments/{attachment_id} +func (s *Server) handleGetAttachmentRequest(args [1]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { + statusWriter := &codeRecorder{ResponseWriter: w} + w = statusWriter + ctx := r.Context() + + var ( + err error + opErrContext = ogenerrors.OperationContext{ + Name: GetAttachmentOperation, + ID: "getAttachment", + } + ) + { + type bitset = [1]uint8 + var satisfied bitset + { + sctx, ok, err := s.securityBearerAuth(ctx, GetAttachmentOperation, r) + if err != nil { + err = &ogenerrors.SecurityError{ + OperationContext: opErrContext, + Security: "BearerAuth", + Err: err, + } + defer recordError("Security:BearerAuth", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + if ok { + satisfied[0] |= 1 << 0 + ctx = sctx + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + err = &ogenerrors.SecurityError{ + OperationContext: opErrContext, + Err: ogenerrors.ErrSecurityRequirementIsNotSatisfied, + } + defer recordError("Security", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + } + params, err := decodeGetAttachmentParams(args, argsEscaped, r) + if err != nil { + err = &ogenerrors.DecodeParamsError{ + OperationContext: opErrContext, + Err: err, + } + defer recordError("DecodeParams", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + var rawBody []byte + + var response GetAttachmentRes + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: GetAttachmentOperation, + OperationSummary: "Метаданные вложения, доступ участникам чата", + OperationID: "getAttachment", + Body: nil, + RawBody: rawBody, + Params: middleware.Parameters{ + { + Name: "attachment_id", + In: "path", + }: params.AttachmentID, + }, + Raw: r, + } + + type ( + Request = struct{} + Params = GetAttachmentParams + Response = GetAttachmentRes + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + unpackGetAttachmentParams, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.GetAttachment(ctx, params) + return response, err + }, + ) + } else { + response, err = s.h.GetAttachment(ctx, params) + } + if err != nil { + defer recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeGetAttachmentResponse(response, w); err != nil { + defer recordError("EncodeResponse", err) + if !errors.Is(err, ht.ErrInternalServerErrorResponse) { + s.cfg.ErrorHandler(ctx, w, r, err) + } + return + } +} + // handleGetChatRequest handles getChat operation. // // Получить доступный чат. @@ -1251,3 +1511,150 @@ func (s *Server) handleRevokeSessionRequest(args [0]string, argsEscaped bool, w return } } + +// handleUploadAttachmentRequest handles uploadAttachment operation. +// +// Принять один PNG/JPEG, до 10 MiB. +// +// POST /api/v1/chats/{chat_id}/attachments +func (s *Server) handleUploadAttachmentRequest(args [1]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { + statusWriter := &codeRecorder{ResponseWriter: w} + w = statusWriter + ctx := r.Context() + + var ( + err error + opErrContext = ogenerrors.OperationContext{ + Name: UploadAttachmentOperation, + ID: "uploadAttachment", + } + ) + { + type bitset = [1]uint8 + var satisfied bitset + { + sctx, ok, err := s.securityBearerAuth(ctx, UploadAttachmentOperation, r) + if err != nil { + err = &ogenerrors.SecurityError{ + OperationContext: opErrContext, + Security: "BearerAuth", + Err: err, + } + defer recordError("Security:BearerAuth", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + if ok { + satisfied[0] |= 1 << 0 + ctx = sctx + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + err = &ogenerrors.SecurityError{ + OperationContext: opErrContext, + Err: ogenerrors.ErrSecurityRequirementIsNotSatisfied, + } + defer recordError("Security", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + } + params, err := decodeUploadAttachmentParams(args, argsEscaped, r) + if err != nil { + err = &ogenerrors.DecodeParamsError{ + OperationContext: opErrContext, + Err: err, + } + defer recordError("DecodeParams", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + var rawBody []byte + request, rawBody, close, err := s.decodeUploadAttachmentRequest(r) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + defer recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response UploadAttachmentRes + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: UploadAttachmentOperation, + OperationSummary: "Принять один PNG/JPEG, до 10 MiB", + OperationID: "uploadAttachment", + Body: request, + RawBody: rawBody, + Params: middleware.Parameters{ + { + Name: "chat_id", + In: "path", + }: params.ChatID, + { + Name: "filename", + In: "query", + }: params.Filename, + }, + Raw: r, + } + + type ( + Request = UploadAttachmentReq + Params = UploadAttachmentParams + Response = UploadAttachmentRes + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + unpackUploadAttachmentParams, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.UploadAttachment(ctx, request, params) + return response, err + }, + ) + } else { + response, err = s.h.UploadAttachment(ctx, request, params) + } + if err != nil { + defer recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeUploadAttachmentResponse(response, w); err != nil { + defer recordError("EncodeResponse", err) + if !errors.Is(err, ht.ErrInternalServerErrorResponse) { + s.cfg.ErrorHandler(ctx, w, r, err) + } + return + } +} diff --git a/internal/transport/rest/internal/oas/oas_interfaces_gen.go b/internal/transport/rest/internal/oas/oas_interfaces_gen.go index aa93e9de..113887ed 100644 --- a/internal/transport/rest/internal/oas/oas_interfaces_gen.go +++ b/internal/transport/rest/internal/oas/oas_interfaces_gen.go @@ -17,6 +17,14 @@ type CurrentUserRes interface { currentUserRes() } +type DownloadAttachmentRes interface { + downloadAttachmentRes() +} + +type GetAttachmentRes interface { + getAttachmentRes() +} + type GetChatRes interface { getChatRes() } @@ -44,3 +52,11 @@ type RegisterUserRes interface { type RevokeSessionRes interface { revokeSessionRes() } + +type UploadAttachmentReq interface { + uploadAttachmentReq() +} + +type UploadAttachmentRes interface { + uploadAttachmentRes() +} diff --git a/internal/transport/rest/internal/oas/oas_json_gen.go b/internal/transport/rest/internal/oas/oas_json_gen.go index 7642cbf6..2d7b593f 100644 --- a/internal/transport/rest/internal/oas/oas_json_gen.go +++ b/internal/transport/rest/internal/oas/oas_json_gen.go @@ -13,6 +13,372 @@ import ( "github.com/ogen-go/ogen/validate" ) +// Encode implements json.Marshaler. +func (s *Attachment) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *Attachment) encodeFields(e *jx.Encoder) { + { + e.FieldStart("chat_id") + json.EncodeUUID(e, s.ChatID) + } + { + e.FieldStart("content_type") + s.ContentType.Encode(e) + } + { + e.FieldStart("created_at") + json.EncodeDateTime(e, s.CreatedAt) + } + { + e.FieldStart("error_code") + s.ErrorCode.Encode(e) + } + { + e.FieldStart("filename") + e.Str(s.Filename) + } + { + e.FieldStart("id") + json.EncodeUUID(e, s.ID) + } + { + e.FieldStart("owner_id") + json.EncodeUUID(e, s.OwnerID) + } + { + e.FieldStart("sha256") + e.Str(s.SHA256) + } + { + e.FieldStart("size_bytes") + e.Int(s.SizeBytes) + } + { + e.FieldStart("status") + s.Status.Encode(e) + } + { + e.FieldStart("updated_at") + json.EncodeDateTime(e, s.UpdatedAt) + } + { + e.FieldStart("variants") + e.ArrStart() + for _, elem := range s.Variants { + elem.Encode(e) + } + e.ArrEnd() + } +} + +var jsonFieldsNameOfAttachment = [12]string{ + 0: "chat_id", + 1: "content_type", + 2: "created_at", + 3: "error_code", + 4: "filename", + 5: "id", + 6: "owner_id", + 7: "sha256", + 8: "size_bytes", + 9: "status", + 10: "updated_at", + 11: "variants", +} + +// Decode decodes Attachment from json. +func (s *Attachment) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode Attachment to nil") + } + var requiredBitSet [2]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "chat_id": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := json.DecodeUUID(d) + s.ChatID = v + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"chat_id\"") + } + case "content_type": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + if err := s.ContentType.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"content_type\"") + } + case "created_at": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := json.DecodeDateTime(d) + s.CreatedAt = v + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"created_at\"") + } + case "error_code": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + if err := s.ErrorCode.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"error_code\"") + } + case "filename": + requiredBitSet[0] |= 1 << 4 + if err := func() error { + v, err := d.Str() + s.Filename = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"filename\"") + } + case "id": + requiredBitSet[0] |= 1 << 5 + if err := func() error { + v, err := json.DecodeUUID(d) + s.ID = v + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"id\"") + } + case "owner_id": + requiredBitSet[0] |= 1 << 6 + if err := func() error { + v, err := json.DecodeUUID(d) + s.OwnerID = v + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"owner_id\"") + } + case "sha256": + requiredBitSet[0] |= 1 << 7 + if err := func() error { + v, err := d.Str() + s.SHA256 = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"sha256\"") + } + case "size_bytes": + requiredBitSet[1] |= 1 << 0 + if err := func() error { + v, err := d.Int() + s.SizeBytes = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"size_bytes\"") + } + case "status": + requiredBitSet[1] |= 1 << 1 + if err := func() error { + if err := s.Status.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"status\"") + } + case "updated_at": + requiredBitSet[1] |= 1 << 2 + if err := func() error { + v, err := json.DecodeDateTime(d) + s.UpdatedAt = v + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"updated_at\"") + } + case "variants": + requiredBitSet[1] |= 1 << 3 + if err := func() error { + s.Variants = make([]Variant, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem Variant + if err := elem.Decode(d); err != nil { + return err + } + s.Variants = append(s.Variants, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"variants\"") + } + default: + return errors.Errorf("unexpected field %q", k) + } + return nil + }); err != nil { + return errors.Wrap(err, "decode Attachment") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [2]uint8{ + 0b11111111, + 0b00001111, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfAttachment) { + name = jsonFieldsNameOfAttachment[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *Attachment) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *Attachment) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes AttachmentContentType as json. +func (s AttachmentContentType) Encode(e *jx.Encoder) { + e.Str(string(s)) +} + +// Decode decodes AttachmentContentType from json. +func (s *AttachmentContentType) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode AttachmentContentType to nil") + } + v, err := d.StrBytes() + if err != nil { + return err + } + // Try to use constant string. + switch AttachmentContentType(v) { + case AttachmentContentTypeImagePNG: + *s = AttachmentContentTypeImagePNG + case AttachmentContentTypeImageJpeg: + *s = AttachmentContentTypeImageJpeg + default: + *s = AttachmentContentType(v) + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s AttachmentContentType) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *AttachmentContentType) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes AttachmentStatus as json. +func (s AttachmentStatus) Encode(e *jx.Encoder) { + e.Str(string(s)) +} + +// Decode decodes AttachmentStatus from json. +func (s *AttachmentStatus) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode AttachmentStatus to nil") + } + v, err := d.StrBytes() + if err != nil { + return err + } + // Try to use constant string. + switch AttachmentStatus(v) { + case AttachmentStatusReady: + *s = AttachmentStatusReady + default: + *s = AttachmentStatus(v) + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s AttachmentStatus) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *AttachmentStatus) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode implements json.Marshaler. func (s *Chat) Encode(e *jx.Encoder) { e.ObjStart() @@ -23,12 +389,12 @@ func (s *Chat) Encode(e *jx.Encoder) { // encodeFields encodes fields. func (s *Chat) encodeFields(e *jx.Encoder) { { - e.FieldStart("id") - json.EncodeUUID(e, s.ID) + e.FieldStart("created_at") + json.EncodeDateTime(e, s.CreatedAt) } { - e.FieldStart("title") - e.Str(s.Title) + e.FieldStart("id") + json.EncodeUUID(e, s.ID) } { e.FieldStart("member_ids") @@ -39,16 +405,16 @@ func (s *Chat) encodeFields(e *jx.Encoder) { e.ArrEnd() } { - e.FieldStart("created_at") - json.EncodeDateTime(e, s.CreatedAt) + e.FieldStart("title") + e.Str(s.Title) } } var jsonFieldsNameOfChat = [4]string{ - 0: "id", - 1: "title", + 0: "created_at", + 1: "id", 2: "member_ids", - 3: "created_at", + 3: "title", } // Decode decodes Chat from json. @@ -60,8 +426,20 @@ func (s *Chat) Decode(d *jx.Decoder) error { if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "id": + case "created_at": requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := json.DecodeDateTime(d) + s.CreatedAt = v + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"created_at\"") + } + case "id": + requiredBitSet[0] |= 1 << 1 if err := func() error { v, err := json.DecodeUUID(d) s.ID = v @@ -72,18 +450,6 @@ func (s *Chat) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"id\"") } - case "title": - requiredBitSet[0] |= 1 << 1 - if err := func() error { - v, err := d.Str() - s.Title = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"title\"") - } case "member_ids": requiredBitSet[0] |= 1 << 2 if err := func() error { @@ -104,17 +470,17 @@ func (s *Chat) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"member_ids\"") } - case "created_at": + case "title": requiredBitSet[0] |= 1 << 3 if err := func() error { - v, err := json.DecodeDateTime(d) - s.CreatedAt = v + v, err := d.Str() + s.Title = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"created_at\"") + return errors.Wrap(err, "decode field \"title\"") } default: return errors.Errorf("unexpected field %q", k) @@ -302,10 +668,6 @@ func (s *CreateChat) Encode(e *jx.Encoder) { // encodeFields encodes fields. func (s *CreateChat) encodeFields(e *jx.Encoder) { - { - e.FieldStart("title") - e.Str(s.Title) - } { e.FieldStart("member_ids") e.ArrStart() @@ -314,11 +676,15 @@ func (s *CreateChat) encodeFields(e *jx.Encoder) { } e.ArrEnd() } + { + e.FieldStart("title") + e.Str(s.Title) + } } var jsonFieldsNameOfCreateChat = [2]string{ - 0: "title", - 1: "member_ids", + 0: "member_ids", + 1: "title", } // Decode decodes CreateChat from json. @@ -330,20 +696,8 @@ func (s *CreateChat) Decode(d *jx.Decoder) error { if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "title": - requiredBitSet[0] |= 1 << 0 - if err := func() error { - v, err := d.Str() - s.Title = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"title\"") - } case "member_ids": - requiredBitSet[0] |= 1 << 1 + requiredBitSet[0] |= 1 << 0 if err := func() error { s.MemberIds = make([]uuid.UUID, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -362,6 +716,18 @@ func (s *CreateChat) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"member_ids\"") } + case "title": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.Title = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"title\"") + } default: return errors.Errorf("unexpected field %q", k) } @@ -427,14 +793,25 @@ func (s *CreateMessage) Encode(e *jx.Encoder) { // encodeFields encodes fields. func (s *CreateMessage) encodeFields(e *jx.Encoder) { + { + if s.AttachmentIds != nil { + e.FieldStart("attachment_ids") + e.ArrStart() + for _, elem := range s.AttachmentIds { + json.EncodeUUID(e, elem) + } + e.ArrEnd() + } + } { e.FieldStart("text") e.Str(s.Text) } } -var jsonFieldsNameOfCreateMessage = [1]string{ - 0: "text", +var jsonFieldsNameOfCreateMessage = [2]string{ + 0: "attachment_ids", + 1: "text", } // Decode decodes CreateMessage from json. @@ -443,11 +820,31 @@ func (s *CreateMessage) Decode(d *jx.Decoder) error { return errors.New("invalid: unable to decode CreateMessage to nil") } var requiredBitSet [1]uint8 + s.setDefaults() if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { + case "attachment_ids": + if err := func() error { + s.AttachmentIds = make([]uuid.UUID, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem uuid.UUID + v, err := json.DecodeUUID(d) + elem = v + if err != nil { + return err + } + s.AttachmentIds = append(s.AttachmentIds, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"attachment_ids\"") + } case "text": - requiredBitSet[0] |= 1 << 0 + requiredBitSet[0] |= 1 << 1 if err := func() error { v, err := d.Str() s.Text = string(v) @@ -468,7 +865,7 @@ func (s *CreateMessage) Decode(d *jx.Decoder) error { // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000001, + 0b00000010, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -523,10 +920,6 @@ func (s *CreateUser) Encode(e *jx.Encoder) { // encodeFields encodes fields. func (s *CreateUser) encodeFields(e *jx.Encoder) { - { - e.FieldStart("username") - e.Str(s.Username) - } { e.FieldStart("display_name") e.Str(s.DisplayName) @@ -535,12 +928,16 @@ func (s *CreateUser) encodeFields(e *jx.Encoder) { e.FieldStart("password") e.Str(s.Password) } + { + e.FieldStart("username") + e.Str(s.Username) + } } var jsonFieldsNameOfCreateUser = [3]string{ - 0: "username", - 1: "display_name", - 2: "password", + 0: "display_name", + 1: "password", + 2: "username", } // Decode decodes CreateUser from json. @@ -552,20 +949,8 @@ func (s *CreateUser) Decode(d *jx.Decoder) error { if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "username": - requiredBitSet[0] |= 1 << 0 - if err := func() error { - v, err := d.Str() - s.Username = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"username\"") - } case "display_name": - requiredBitSet[0] |= 1 << 1 + requiredBitSet[0] |= 1 << 0 if err := func() error { v, err := d.Str() s.DisplayName = string(v) @@ -577,7 +962,7 @@ func (s *CreateUser) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"display_name\"") } case "password": - requiredBitSet[0] |= 1 << 2 + requiredBitSet[0] |= 1 << 1 if err := func() error { v, err := d.Str() s.Password = string(v) @@ -588,6 +973,18 @@ func (s *CreateUser) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"password\"") } + case "username": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Str() + s.Username = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"username\"") + } default: return errors.Errorf("unexpected field %q", k) } @@ -1062,13 +1459,25 @@ func (s *Message) Encode(e *jx.Encoder) { // encodeFields encodes fields. func (s *Message) encodeFields(e *jx.Encoder) { { - e.FieldStart("id") - json.EncodeUUID(e, s.ID) + e.FieldStart("attachment_ids") + e.ArrStart() + for _, elem := range s.AttachmentIds { + json.EncodeUUID(e, elem) + } + e.ArrEnd() } { e.FieldStart("chat_id") json.EncodeUUID(e, s.ChatID) } + { + e.FieldStart("created_at") + json.EncodeDateTime(e, s.CreatedAt) + } + { + e.FieldStart("id") + json.EncodeUUID(e, s.ID) + } { e.FieldStart("sender_id") json.EncodeUUID(e, s.SenderID) @@ -1077,18 +1486,15 @@ func (s *Message) encodeFields(e *jx.Encoder) { e.FieldStart("text") e.Str(s.Text) } - { - e.FieldStart("created_at") - json.EncodeDateTime(e, s.CreatedAt) - } } -var jsonFieldsNameOfMessage = [5]string{ - 0: "id", +var jsonFieldsNameOfMessage = [6]string{ + 0: "attachment_ids", 1: "chat_id", - 2: "sender_id", - 3: "text", - 4: "created_at", + 2: "created_at", + 3: "id", + 4: "sender_id", + 5: "text", } // Decode decodes Message from json. @@ -1100,17 +1506,25 @@ func (s *Message) Decode(d *jx.Decoder) error { if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "id": + case "attachment_ids": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := json.DecodeUUID(d) - s.ID = v - if err != nil { + s.AttachmentIds = make([]uuid.UUID, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem uuid.UUID + v, err := json.DecodeUUID(d) + elem = v + if err != nil { + return err + } + s.AttachmentIds = append(s.AttachmentIds, elem) + return nil + }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"id\"") + return errors.Wrap(err, "decode field \"attachment_ids\"") } case "chat_id": requiredBitSet[0] |= 1 << 1 @@ -1124,8 +1538,32 @@ func (s *Message) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"chat_id\"") } - case "sender_id": + case "created_at": requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := json.DecodeDateTime(d) + s.CreatedAt = v + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"created_at\"") + } + case "id": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + v, err := json.DecodeUUID(d) + s.ID = v + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"id\"") + } + case "sender_id": + requiredBitSet[0] |= 1 << 4 if err := func() error { v, err := json.DecodeUUID(d) s.SenderID = v @@ -1137,7 +1575,7 @@ func (s *Message) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"sender_id\"") } case "text": - requiredBitSet[0] |= 1 << 3 + requiredBitSet[0] |= 1 << 5 if err := func() error { v, err := d.Str() s.Text = string(v) @@ -1148,18 +1586,6 @@ func (s *Message) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"text\"") } - case "created_at": - requiredBitSet[0] |= 1 << 4 - if err := func() error { - v, err := json.DecodeDateTime(d) - s.CreatedAt = v - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"created_at\"") - } default: return errors.Errorf("unexpected field %q", k) } @@ -1170,7 +1596,7 @@ func (s *Message) Decode(d *jx.Decoder) error { // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00011111, + 0b00111111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -1392,6 +1818,10 @@ func (s *Session) Encode(e *jx.Encoder) { // encodeFields encodes fields. func (s *Session) encodeFields(e *jx.Encoder) { + { + e.FieldStart("expires_at") + json.EncodeDateTime(e, s.ExpiresAt) + } { e.FieldStart("token") e.Str(s.Token) @@ -1400,10 +1830,6 @@ func (s *Session) encodeFields(e *jx.Encoder) { e.FieldStart("token_type") e.Str("Bearer") } - { - e.FieldStart("expires_at") - json.EncodeDateTime(e, s.ExpiresAt) - } { e.FieldStart("user") s.User.Encode(e) @@ -1411,9 +1837,9 @@ func (s *Session) encodeFields(e *jx.Encoder) { } var jsonFieldsNameOfSession = [4]string{ - 0: "token", - 1: "token_type", - 2: "expires_at", + 0: "expires_at", + 1: "token", + 2: "token_type", 3: "user", } @@ -1426,8 +1852,20 @@ func (s *Session) Decode(d *jx.Decoder) error { if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "token": + case "expires_at": requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := json.DecodeDateTime(d) + s.ExpiresAt = v + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"expires_at\"") + } + case "token": + requiredBitSet[0] |= 1 << 1 if err := func() error { v, err := d.Str() s.Token = string(v) @@ -1439,7 +1877,7 @@ func (s *Session) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"token\"") } case "token_type": - requiredBitSet[0] |= 1 << 1 + requiredBitSet[0] |= 1 << 2 if err := func() error { v, err := d.Str() s.TokenType = string(v) @@ -1450,18 +1888,6 @@ func (s *Session) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"token_type\"") } - case "expires_at": - requiredBitSet[0] |= 1 << 2 - if err := func() error { - v, err := json.DecodeDateTime(d) - s.ExpiresAt = v - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"expires_at\"") - } case "user": requiredBitSet[0] |= 1 << 3 if err := func() error { @@ -1537,6 +1963,14 @@ func (s *User) Encode(e *jx.Encoder) { // encodeFields encodes fields. func (s *User) encodeFields(e *jx.Encoder) { + { + e.FieldStart("created_at") + json.EncodeDateTime(e, s.CreatedAt) + } + { + e.FieldStart("display_name") + e.Str(s.DisplayName) + } { e.FieldStart("id") json.EncodeUUID(e, s.ID) @@ -1545,21 +1979,13 @@ func (s *User) encodeFields(e *jx.Encoder) { e.FieldStart("username") e.Str(s.Username) } - { - e.FieldStart("display_name") - e.Str(s.DisplayName) - } - { - e.FieldStart("created_at") - json.EncodeDateTime(e, s.CreatedAt) - } } var jsonFieldsNameOfUser = [4]string{ - 0: "id", - 1: "username", - 2: "display_name", - 3: "created_at", + 0: "created_at", + 1: "display_name", + 2: "id", + 3: "username", } // Decode decodes User from json. @@ -1571,8 +1997,32 @@ func (s *User) Decode(d *jx.Decoder) error { if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "id": + case "created_at": requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := json.DecodeDateTime(d) + s.CreatedAt = v + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"created_at\"") + } + case "display_name": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.DisplayName = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"display_name\"") + } + case "id": + requiredBitSet[0] |= 1 << 2 if err := func() error { v, err := json.DecodeUUID(d) s.ID = v @@ -1584,7 +2034,7 @@ func (s *User) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"id\"") } case "username": - requiredBitSet[0] |= 1 << 1 + requiredBitSet[0] |= 1 << 3 if err := func() error { v, err := d.Str() s.Username = string(v) @@ -1595,30 +2045,6 @@ func (s *User) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"username\"") } - case "display_name": - requiredBitSet[0] |= 1 << 2 - if err := func() error { - v, err := d.Str() - s.DisplayName = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"display_name\"") - } - case "created_at": - requiredBitSet[0] |= 1 << 3 - if err := func() error { - v, err := json.DecodeDateTime(d) - s.CreatedAt = v - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"created_at\"") - } default: return errors.Errorf("unexpected field %q", k) } @@ -1674,3 +2100,264 @@ func (s *User) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } + +// Encode implements json.Marshaler. +func (s *Variant) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *Variant) encodeFields(e *jx.Encoder) { + { + e.FieldStart("content_type") + s.ContentType.Encode(e) + } + { + e.FieldStart("height") + e.Int(s.Height) + } + { + e.FieldStart("name") + s.Name.Encode(e) + } + { + e.FieldStart("sha256") + e.Str(s.SHA256) + } + { + e.FieldStart("size_bytes") + e.Int(s.SizeBytes) + } + { + e.FieldStart("width") + e.Int(s.Width) + } +} + +var jsonFieldsNameOfVariant = [6]string{ + 0: "content_type", + 1: "height", + 2: "name", + 3: "sha256", + 4: "size_bytes", + 5: "width", +} + +// Decode decodes Variant from json. +func (s *Variant) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode Variant to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "content_type": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + if err := s.ContentType.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"content_type\"") + } + case "height": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Int() + s.Height = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"height\"") + } + case "name": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + if err := s.Name.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"name\"") + } + case "sha256": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + v, err := d.Str() + s.SHA256 = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"sha256\"") + } + case "size_bytes": + requiredBitSet[0] |= 1 << 4 + if err := func() error { + v, err := d.Int() + s.SizeBytes = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"size_bytes\"") + } + case "width": + requiredBitSet[0] |= 1 << 5 + if err := func() error { + v, err := d.Int() + s.Width = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"width\"") + } + default: + return errors.Errorf("unexpected field %q", k) + } + return nil + }); err != nil { + return errors.Wrap(err, "decode Variant") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00111111, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfVariant) { + name = jsonFieldsNameOfVariant[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *Variant) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *Variant) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes VariantContentType as json. +func (s VariantContentType) Encode(e *jx.Encoder) { + e.Str(string(s)) +} + +// Decode decodes VariantContentType from json. +func (s *VariantContentType) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode VariantContentType to nil") + } + v, err := d.StrBytes() + if err != nil { + return err + } + // Try to use constant string. + switch VariantContentType(v) { + case VariantContentTypeImageJpeg: + *s = VariantContentTypeImageJpeg + case VariantContentTypeImagePNG: + *s = VariantContentTypeImagePNG + case VariantContentTypeImageWEBP: + *s = VariantContentTypeImageWEBP + default: + *s = VariantContentType(v) + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s VariantContentType) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *VariantContentType) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes VariantName as json. +func (s VariantName) Encode(e *jx.Encoder) { + e.Str(string(s)) +} + +// Decode decodes VariantName from json. +func (s *VariantName) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode VariantName to nil") + } + v, err := d.StrBytes() + if err != nil { + return err + } + // Try to use constant string. + switch VariantName(v) { + case VariantNameThumbnail: + *s = VariantNameThumbnail + case VariantNameCrop: + *s = VariantNameCrop + case VariantNameOptimized: + *s = VariantNameOptimized + default: + *s = VariantName(v) + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s VariantName) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *VariantName) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} diff --git a/internal/transport/rest/internal/oas/oas_operations_gen.go b/internal/transport/rest/internal/oas/oas_operations_gen.go index b182d0a6..e078e472 100644 --- a/internal/transport/rest/internal/oas/oas_operations_gen.go +++ b/internal/transport/rest/internal/oas/oas_operations_gen.go @@ -6,15 +6,18 @@ package oas type OperationName = string const ( - CreateChatOperation OperationName = "CreateChat" - CreateMessageOperation OperationName = "CreateMessage" - CreateSessionOperation OperationName = "CreateSession" - CurrentUserOperation OperationName = "CurrentUser" - GetChatOperation OperationName = "GetChat" - ListChatsOperation OperationName = "ListChats" - ListMessagesOperation OperationName = "ListMessages" - LivenessOperation OperationName = "Liveness" - ReadinessOperation OperationName = "Readiness" - RegisterUserOperation OperationName = "RegisterUser" - RevokeSessionOperation OperationName = "RevokeSession" + CreateChatOperation OperationName = "CreateChat" + CreateMessageOperation OperationName = "CreateMessage" + CreateSessionOperation OperationName = "CreateSession" + CurrentUserOperation OperationName = "CurrentUser" + DownloadAttachmentOperation OperationName = "DownloadAttachment" + GetAttachmentOperation OperationName = "GetAttachment" + GetChatOperation OperationName = "GetChat" + ListChatsOperation OperationName = "ListChats" + ListMessagesOperation OperationName = "ListMessages" + LivenessOperation OperationName = "Liveness" + ReadinessOperation OperationName = "Readiness" + RegisterUserOperation OperationName = "RegisterUser" + RevokeSessionOperation OperationName = "RevokeSession" + UploadAttachmentOperation OperationName = "UploadAttachment" ) diff --git a/internal/transport/rest/internal/oas/oas_parameters_gen.go b/internal/transport/rest/internal/oas/oas_parameters_gen.go index 814390eb..1cb40535 100644 --- a/internal/transport/rest/internal/oas/oas_parameters_gen.go +++ b/internal/transport/rest/internal/oas/oas_parameters_gen.go @@ -147,6 +147,208 @@ func decodeCreateMessageParams(args [1]string, argsEscaped bool, r *http.Request return params, nil } +// DownloadAttachmentParams is parameters of downloadAttachment operation. +type DownloadAttachmentParams struct { + AttachmentID uuid.UUID + Variant OptDownloadAttachmentVariant `json:",omitempty,omitzero"` +} + +func unpackDownloadAttachmentParams(packed middleware.Parameters) (params DownloadAttachmentParams) { + { + key := middleware.ParameterKey{ + Name: "attachment_id", + In: "path", + } + params.AttachmentID = packed[key].(uuid.UUID) + } + { + key := middleware.ParameterKey{ + Name: "variant", + In: "query", + } + if v, ok := packed[key]; ok { + params.Variant = v.(OptDownloadAttachmentVariant) + } + } + return params +} + +func decodeDownloadAttachmentParams(args [1]string, argsEscaped bool, r *http.Request) (params DownloadAttachmentParams, _ error) { + q := uri.NewQueryDecoder(r.URL.Query()) + // Decode path: attachment_id. + if err := func() error { + param := args[0] + if argsEscaped { + unescaped, err := url.PathUnescape(args[0]) + if err != nil { + return errors.Wrap(err, "unescape path") + } + param = unescaped + } + if len(param) > 0 { + d := uri.NewPathDecoder(uri.PathDecoderConfig{ + Param: "attachment_id", + Value: param, + Style: uri.PathStyleSimple, + Explode: false, + }) + + if err := func() error { + val, err := d.DecodeValue() + if err != nil { + return err + } + + c, err := conv.ToUUID(val) + if err != nil { + return err + } + + params.AttachmentID = c + return nil + }(); err != nil { + return err + } + } else { + return validate.ErrFieldRequired + } + return nil + }(); err != nil { + return params, &ogenerrors.DecodeParamError{ + Name: "attachment_id", + In: "path", + Err: err, + } + } + // Set default value for query: variant. + { + val := DownloadAttachmentVariant("original") + params.Variant.SetTo(val) + } + // Decode query: variant. + if err := func() error { + cfg := uri.QueryParameterDecodingConfig{ + Name: "variant", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.HasParam(cfg); err == nil { + if err := q.DecodeParam(cfg, func(d uri.Decoder) error { + var paramsDotVariantVal DownloadAttachmentVariant + if err := func() error { + val, err := d.DecodeValue() + if err != nil { + return err + } + + c, err := conv.ToString(val) + if err != nil { + return err + } + + paramsDotVariantVal = DownloadAttachmentVariant(c) + return nil + }(); err != nil { + return err + } + params.Variant.SetTo(paramsDotVariantVal) + return nil + }); err != nil { + return err + } + if err := func() error { + if value, ok := params.Variant.Get(); ok { + if err := func() error { + if err := value.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + return params, &ogenerrors.DecodeParamError{ + Name: "variant", + In: "query", + Err: err, + } + } + return params, nil +} + +// GetAttachmentParams is parameters of getAttachment operation. +type GetAttachmentParams struct { + AttachmentID uuid.UUID +} + +func unpackGetAttachmentParams(packed middleware.Parameters) (params GetAttachmentParams) { + { + key := middleware.ParameterKey{ + Name: "attachment_id", + In: "path", + } + params.AttachmentID = packed[key].(uuid.UUID) + } + return params +} + +func decodeGetAttachmentParams(args [1]string, argsEscaped bool, r *http.Request) (params GetAttachmentParams, _ error) { + // Decode path: attachment_id. + if err := func() error { + param := args[0] + if argsEscaped { + unescaped, err := url.PathUnescape(args[0]) + if err != nil { + return errors.Wrap(err, "unescape path") + } + param = unescaped + } + if len(param) > 0 { + d := uri.NewPathDecoder(uri.PathDecoderConfig{ + Param: "attachment_id", + Value: param, + Style: uri.PathStyleSimple, + Explode: false, + }) + + if err := func() error { + val, err := d.DecodeValue() + if err != nil { + return err + } + + c, err := conv.ToUUID(val) + if err != nil { + return err + } + + params.AttachmentID = c + return nil + }(); err != nil { + return err + } + } else { + return validate.ErrFieldRequired + } + return nil + }(); err != nil { + return params, &ogenerrors.DecodeParamError{ + Name: "attachment_id", + In: "path", + Err: err, + } + } + return params, nil +} + // GetChatParams is parameters of getChat operation. type GetChatParams struct { ChatID uuid.UUID @@ -608,3 +810,133 @@ func decodeListMessagesParams(args [1]string, argsEscaped bool, r *http.Request) } return params, nil } + +// UploadAttachmentParams is parameters of uploadAttachment operation. +type UploadAttachmentParams struct { + ChatID uuid.UUID + Filename string +} + +func unpackUploadAttachmentParams(packed middleware.Parameters) (params UploadAttachmentParams) { + { + key := middleware.ParameterKey{ + Name: "chat_id", + In: "path", + } + params.ChatID = packed[key].(uuid.UUID) + } + { + key := middleware.ParameterKey{ + Name: "filename", + In: "query", + } + params.Filename = packed[key].(string) + } + return params +} + +func decodeUploadAttachmentParams(args [1]string, argsEscaped bool, r *http.Request) (params UploadAttachmentParams, _ error) { + q := uri.NewQueryDecoder(r.URL.Query()) + // Decode path: chat_id. + if err := func() error { + param := args[0] + if argsEscaped { + unescaped, err := url.PathUnescape(args[0]) + if err != nil { + return errors.Wrap(err, "unescape path") + } + param = unescaped + } + if len(param) > 0 { + d := uri.NewPathDecoder(uri.PathDecoderConfig{ + Param: "chat_id", + Value: param, + Style: uri.PathStyleSimple, + Explode: false, + }) + + if err := func() error { + val, err := d.DecodeValue() + if err != nil { + return err + } + + c, err := conv.ToUUID(val) + if err != nil { + return err + } + + params.ChatID = c + return nil + }(); err != nil { + return err + } + } else { + return validate.ErrFieldRequired + } + return nil + }(); err != nil { + return params, &ogenerrors.DecodeParamError{ + Name: "chat_id", + In: "path", + Err: err, + } + } + // Decode query: filename. + if err := func() error { + cfg := uri.QueryParameterDecodingConfig{ + Name: "filename", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.HasParam(cfg); err == nil { + if err := q.DecodeParam(cfg, func(d uri.Decoder) error { + val, err := d.DecodeValue() + if err != nil { + return err + } + + c, err := conv.ToString(val) + if err != nil { + return err + } + + params.Filename = c + return nil + }); err != nil { + return err + } + if err := func() error { + if err := (validate.String{ + MinLength: 1, + MinLengthSet: true, + MaxLength: 255, + MaxLengthSet: true, + Email: false, + Hostname: false, + Regex: nil, + MinNumeric: 0, + MinNumericSet: false, + MaxNumeric: 0, + MaxNumericSet: false, + }).Validate(string(params.Filename)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + return err + } + } else { + return err + } + return nil + }(); err != nil { + return params, &ogenerrors.DecodeParamError{ + Name: "filename", + In: "query", + Err: err, + } + } + return params, nil +} diff --git a/internal/transport/rest/internal/oas/oas_request_decoders_gen.go b/internal/transport/rest/internal/oas/oas_request_decoders_gen.go index 72c6b1bd..fa4fe504 100644 --- a/internal/transport/rest/internal/oas/oas_request_decoders_gen.go +++ b/internal/transport/rest/internal/oas/oas_request_decoders_gen.go @@ -250,3 +250,42 @@ func (s *Server) decodeRegisterUserRequest(r *http.Request) ( return req, rawBody, close, validate.InvalidContentType(ct) } } + +func (s *Server) decodeUploadAttachmentRequest(r *http.Request) ( + req UploadAttachmentReq, + rawBody []byte, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = errors.Join(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = errors.Join(rerr, close()) + } + }() + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, rawBody, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "image/jpeg": + reader := r.Body + request := UploadAttachmentReqImageJpeg{Data: reader} + return &request, rawBody, close, nil + case ct == "image/png": + reader := r.Body + request := UploadAttachmentReqImagePNG{Data: reader} + return &request, rawBody, close, nil + default: + return req, rawBody, close, validate.InvalidContentType(ct) + } +} diff --git a/internal/transport/rest/internal/oas/oas_response_encoders_gen.go b/internal/transport/rest/internal/oas/oas_response_encoders_gen.go index 3ffd6b6d..003053fe 100644 --- a/internal/transport/rest/internal/oas/oas_response_encoders_gen.go +++ b/internal/transport/rest/internal/oas/oas_response_encoders_gen.go @@ -3,6 +3,7 @@ package oas import ( + "io" "net/http" "github.com/go-faster/errors" @@ -107,7 +108,7 @@ func encodeCreateChatResponse(response CreateChatRes, w http.ResponseWriter) err return nil - case *CreateSessionUnauthorizedHeaders: + case *GetAttachmentUnauthorizedHeaders: w.Header().Set("Content-Type", "application/json; charset=utf-8") w.Header().Set("Access-Control-Expose-Headers", "Www-Authenticate,X-Instance-Id,X-Request-Id") // Encoding response headers. @@ -263,7 +264,7 @@ func encodeCreateChatResponse(response CreateChatRes, w http.ResponseWriter) err return nil - case *CreateSessionTooManyRequestsHeaders: + case *GetAttachmentTooManyRequestsHeaders: w.Header().Set("Content-Type", "application/json; charset=utf-8") w.Header().Set("Access-Control-Expose-Headers", "Retry-After,X-Instance-Id,X-Request-Id") // Encoding response headers. @@ -520,7 +521,7 @@ func encodeCreateMessageResponse(response CreateMessageRes, w http.ResponseWrite return nil - case *CreateSessionUnauthorizedHeaders: + case *GetAttachmentUnauthorizedHeaders: w.Header().Set("Content-Type", "application/json; charset=utf-8") w.Header().Set("Access-Control-Expose-Headers", "Www-Authenticate,X-Instance-Id,X-Request-Id") // Encoding response headers. @@ -676,7 +677,7 @@ func encodeCreateMessageResponse(response CreateMessageRes, w http.ResponseWrite return nil - case *CreateSessionTooManyRequestsHeaders: + case *GetAttachmentTooManyRequestsHeaders: w.Header().Set("Content-Type", "application/json; charset=utf-8") w.Header().Set("Access-Control-Expose-Headers", "Retry-After,X-Instance-Id,X-Request-Id") // Encoding response headers. @@ -933,7 +934,7 @@ func encodeCreateSessionResponse(response CreateSessionRes, w http.ResponseWrite return nil - case *CreateSessionUnauthorizedHeaders: + case *GetAttachmentUnauthorizedHeaders: w.Header().Set("Content-Type", "application/json; charset=utf-8") w.Header().Set("Access-Control-Expose-Headers", "Www-Authenticate,X-Instance-Id,X-Request-Id") // Encoding response headers. @@ -995,7 +996,7 @@ func encodeCreateSessionResponse(response CreateSessionRes, w http.ResponseWrite return nil - case *CreateSessionTooManyRequestsHeaders: + case *GetAttachmentTooManyRequestsHeaders: w.Header().Set("Content-Type", "application/json; charset=utf-8") w.Header().Set("Access-Control-Expose-Headers", "Retry-After,X-Instance-Id,X-Request-Id") // Encoding response headers. @@ -1252,7 +1253,7 @@ func encodeCurrentUserResponse(response CurrentUserRes, w http.ResponseWriter) e return nil - case *CreateSessionUnauthorizedHeaders: + case *GetAttachmentUnauthorizedHeaders: w.Header().Set("Content-Type", "application/json; charset=utf-8") w.Header().Set("Access-Control-Expose-Headers", "Www-Authenticate,X-Instance-Id,X-Request-Id") // Encoding response headers. @@ -1408,7 +1409,7 @@ func encodeCurrentUserResponse(response CurrentUserRes, w http.ResponseWriter) e return nil - case *CreateSessionTooManyRequestsHeaders: + case *GetAttachmentTooManyRequestsHeaders: w.Header().Set("Content-Type", "application/json; charset=utf-8") w.Header().Set("Access-Control-Expose-Headers", "Retry-After,X-Instance-Id,X-Request-Id") // Encoding response headers. @@ -1569,6 +1570,932 @@ func encodeCurrentUserResponse(response CurrentUserRes, w http.ResponseWriter) e } } +func encodeDownloadAttachmentResponse(response DownloadAttachmentRes, w http.ResponseWriter) error { + switch response := response.(type) { + case *DownloadAttachmentOKImageJpegHeaders: + w.Header().Set("Content-Type", "image/jpeg") + w.Header().Set("Access-Control-Expose-Headers", "X-Instance-Id,X-Request-Id") + // Encoding response headers. + { + h := uri.NewHeaderEncoder(w.Header()) + // Encode "X-Instance-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Instance-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XInstanceID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Instance-Id header") + } + } + // Encode "X-Request-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Request-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XRequestID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Request-Id header") + } + } + } + w.WriteHeader(200) + + writer := w + if closer, ok := response.Response.Data.(io.Closer); ok { + defer closer.Close() + } + if _, err := io.Copy(writer, response.Response); err != nil { + return errors.Wrap(err, "write") + } + + return nil + + case *DownloadAttachmentOKImagePNGHeaders: + w.Header().Set("Content-Type", "image/png") + w.Header().Set("Access-Control-Expose-Headers", "X-Instance-Id,X-Request-Id") + // Encoding response headers. + { + h := uri.NewHeaderEncoder(w.Header()) + // Encode "X-Instance-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Instance-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XInstanceID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Instance-Id header") + } + } + // Encode "X-Request-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Request-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XRequestID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Request-Id header") + } + } + } + w.WriteHeader(200) + + writer := w + if closer, ok := response.Response.Data.(io.Closer); ok { + defer closer.Close() + } + if _, err := io.Copy(writer, response.Response); err != nil { + return errors.Wrap(err, "write") + } + + return nil + + case *DownloadAttachmentOKImageWEBPHeaders: + w.Header().Set("Content-Type", "image/webp") + w.Header().Set("Access-Control-Expose-Headers", "X-Instance-Id,X-Request-Id") + // Encoding response headers. + { + h := uri.NewHeaderEncoder(w.Header()) + // Encode "X-Instance-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Instance-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XInstanceID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Instance-Id header") + } + } + // Encode "X-Request-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Request-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XRequestID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Request-Id header") + } + } + } + w.WriteHeader(200) + + writer := w + if closer, ok := response.Response.Data.(io.Closer); ok { + defer closer.Close() + } + if _, err := io.Copy(writer, response.Response); err != nil { + return errors.Wrap(err, "write") + } + + return nil + + case *DownloadAttachmentBadRequest: + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.Header().Set("Access-Control-Expose-Headers", "X-Instance-Id,X-Request-Id") + // Encoding response headers. + { + h := uri.NewHeaderEncoder(w.Header()) + // Encode "X-Instance-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Instance-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XInstanceID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Instance-Id header") + } + } + // Encode "X-Request-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Request-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XRequestID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Request-Id header") + } + } + } + w.WriteHeader(400) + + e := new(jx.Encoder) + response.Response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil + + case *GetAttachmentUnauthorizedHeaders: + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.Header().Set("Access-Control-Expose-Headers", "Www-Authenticate,X-Instance-Id,X-Request-Id") + // Encoding response headers. + { + h := uri.NewHeaderEncoder(w.Header()) + // Encode "WWW-Authenticate" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "WWW-Authenticate", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.WWWAuthenticate.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode WWW-Authenticate header") + } + } + // Encode "X-Instance-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Instance-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XInstanceID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Instance-Id header") + } + } + // Encode "X-Request-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Request-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XRequestID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Request-Id header") + } + } + } + w.WriteHeader(401) + + e := new(jx.Encoder) + response.Response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil + + case *DownloadAttachmentNotFound: + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.Header().Set("Access-Control-Expose-Headers", "X-Instance-Id,X-Request-Id") + // Encoding response headers. + { + h := uri.NewHeaderEncoder(w.Header()) + // Encode "X-Instance-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Instance-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XInstanceID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Instance-Id header") + } + } + // Encode "X-Request-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Request-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XRequestID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Request-Id header") + } + } + } + w.WriteHeader(404) + + e := new(jx.Encoder) + response.Response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil + + case *DownloadAttachmentConflict: + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.Header().Set("Access-Control-Expose-Headers", "X-Instance-Id,X-Request-Id") + // Encoding response headers. + { + h := uri.NewHeaderEncoder(w.Header()) + // Encode "X-Instance-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Instance-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XInstanceID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Instance-Id header") + } + } + // Encode "X-Request-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Request-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XRequestID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Request-Id header") + } + } + } + w.WriteHeader(409) + + e := new(jx.Encoder) + response.Response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil + + case *GetAttachmentTooManyRequestsHeaders: + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.Header().Set("Access-Control-Expose-Headers", "Retry-After,X-Instance-Id,X-Request-Id") + // Encoding response headers. + { + h := uri.NewHeaderEncoder(w.Header()) + // Encode "Retry-After" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "Retry-After", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.RetryAfter.Get(); ok { + return e.EncodeValue(conv.IntToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode Retry-After header") + } + } + // Encode "X-Instance-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Instance-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XInstanceID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Instance-Id header") + } + } + // Encode "X-Request-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Request-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XRequestID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Request-Id header") + } + } + } + w.WriteHeader(429) + + e := new(jx.Encoder) + response.Response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil + + case *DownloadAttachmentInternalServerError: + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.Header().Set("Access-Control-Expose-Headers", "X-Instance-Id,X-Request-Id") + // Encoding response headers. + { + h := uri.NewHeaderEncoder(w.Header()) + // Encode "X-Instance-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Instance-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XInstanceID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Instance-Id header") + } + } + // Encode "X-Request-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Request-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XRequestID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Request-Id header") + } + } + } + w.WriteHeader(500) + + e := new(jx.Encoder) + response.Response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil + + case *DownloadAttachmentServiceUnavailable: + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.Header().Set("Access-Control-Expose-Headers", "X-Instance-Id,X-Request-Id") + // Encoding response headers. + { + h := uri.NewHeaderEncoder(w.Header()) + // Encode "X-Instance-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Instance-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XInstanceID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Instance-Id header") + } + } + // Encode "X-Request-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Request-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XRequestID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Request-Id header") + } + } + } + w.WriteHeader(503) + + e := new(jx.Encoder) + response.Response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil + + default: + return errors.Errorf("unexpected response type: %T", response) + } +} + +func encodeGetAttachmentResponse(response GetAttachmentRes, w http.ResponseWriter) error { + switch response := response.(type) { + case *AttachmentHeaders: + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.Header().Set("Access-Control-Expose-Headers", "X-Instance-Id,X-Request-Id") + // Encoding response headers. + { + h := uri.NewHeaderEncoder(w.Header()) + // Encode "X-Instance-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Instance-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XInstanceID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Instance-Id header") + } + } + // Encode "X-Request-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Request-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XRequestID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Request-Id header") + } + } + } + w.WriteHeader(200) + + e := new(jx.Encoder) + response.Response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil + + case *GetAttachmentBadRequest: + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.Header().Set("Access-Control-Expose-Headers", "X-Instance-Id,X-Request-Id") + // Encoding response headers. + { + h := uri.NewHeaderEncoder(w.Header()) + // Encode "X-Instance-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Instance-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XInstanceID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Instance-Id header") + } + } + // Encode "X-Request-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Request-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XRequestID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Request-Id header") + } + } + } + w.WriteHeader(400) + + e := new(jx.Encoder) + response.Response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil + + case *GetAttachmentUnauthorizedHeaders: + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.Header().Set("Access-Control-Expose-Headers", "Www-Authenticate,X-Instance-Id,X-Request-Id") + // Encoding response headers. + { + h := uri.NewHeaderEncoder(w.Header()) + // Encode "WWW-Authenticate" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "WWW-Authenticate", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.WWWAuthenticate.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode WWW-Authenticate header") + } + } + // Encode "X-Instance-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Instance-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XInstanceID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Instance-Id header") + } + } + // Encode "X-Request-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Request-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XRequestID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Request-Id header") + } + } + } + w.WriteHeader(401) + + e := new(jx.Encoder) + response.Response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil + + case *GetAttachmentNotFound: + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.Header().Set("Access-Control-Expose-Headers", "X-Instance-Id,X-Request-Id") + // Encoding response headers. + { + h := uri.NewHeaderEncoder(w.Header()) + // Encode "X-Instance-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Instance-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XInstanceID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Instance-Id header") + } + } + // Encode "X-Request-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Request-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XRequestID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Request-Id header") + } + } + } + w.WriteHeader(404) + + e := new(jx.Encoder) + response.Response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil + + case *GetAttachmentConflict: + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.Header().Set("Access-Control-Expose-Headers", "X-Instance-Id,X-Request-Id") + // Encoding response headers. + { + h := uri.NewHeaderEncoder(w.Header()) + // Encode "X-Instance-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Instance-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XInstanceID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Instance-Id header") + } + } + // Encode "X-Request-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Request-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XRequestID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Request-Id header") + } + } + } + w.WriteHeader(409) + + e := new(jx.Encoder) + response.Response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil + + case *GetAttachmentTooManyRequestsHeaders: + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.Header().Set("Access-Control-Expose-Headers", "Retry-After,X-Instance-Id,X-Request-Id") + // Encoding response headers. + { + h := uri.NewHeaderEncoder(w.Header()) + // Encode "Retry-After" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "Retry-After", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.RetryAfter.Get(); ok { + return e.EncodeValue(conv.IntToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode Retry-After header") + } + } + // Encode "X-Instance-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Instance-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XInstanceID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Instance-Id header") + } + } + // Encode "X-Request-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Request-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XRequestID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Request-Id header") + } + } + } + w.WriteHeader(429) + + e := new(jx.Encoder) + response.Response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil + + case *GetAttachmentInternalServerError: + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.Header().Set("Access-Control-Expose-Headers", "X-Instance-Id,X-Request-Id") + // Encoding response headers. + { + h := uri.NewHeaderEncoder(w.Header()) + // Encode "X-Instance-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Instance-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XInstanceID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Instance-Id header") + } + } + // Encode "X-Request-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Request-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XRequestID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Request-Id header") + } + } + } + w.WriteHeader(500) + + e := new(jx.Encoder) + response.Response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil + + case *GetAttachmentServiceUnavailable: + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.Header().Set("Access-Control-Expose-Headers", "X-Instance-Id,X-Request-Id") + // Encoding response headers. + { + h := uri.NewHeaderEncoder(w.Header()) + // Encode "X-Instance-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Instance-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XInstanceID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Instance-Id header") + } + } + // Encode "X-Request-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Request-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XRequestID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Request-Id header") + } + } + } + w.WriteHeader(503) + + e := new(jx.Encoder) + response.Response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil + + default: + return errors.Errorf("unexpected response type: %T", response) + } +} + func encodeGetChatResponse(response GetChatRes, w http.ResponseWriter) error { switch response := response.(type) { case *ChatHeaders: @@ -1665,7 +2592,7 @@ func encodeGetChatResponse(response GetChatRes, w http.ResponseWriter) error { return nil - case *CreateSessionUnauthorizedHeaders: + case *GetAttachmentUnauthorizedHeaders: w.Header().Set("Content-Type", "application/json; charset=utf-8") w.Header().Set("Access-Control-Expose-Headers", "Www-Authenticate,X-Instance-Id,X-Request-Id") // Encoding response headers. @@ -1821,7 +2748,7 @@ func encodeGetChatResponse(response GetChatRes, w http.ResponseWriter) error { return nil - case *CreateSessionTooManyRequestsHeaders: + case *GetAttachmentTooManyRequestsHeaders: w.Header().Set("Content-Type", "application/json; charset=utf-8") w.Header().Set("Access-Control-Expose-Headers", "Retry-After,X-Instance-Id,X-Request-Id") // Encoding response headers. @@ -2078,7 +3005,7 @@ func encodeListChatsResponse(response ListChatsRes, w http.ResponseWriter) error return nil - case *CreateSessionUnauthorizedHeaders: + case *GetAttachmentUnauthorizedHeaders: w.Header().Set("Content-Type", "application/json; charset=utf-8") w.Header().Set("Access-Control-Expose-Headers", "Www-Authenticate,X-Instance-Id,X-Request-Id") // Encoding response headers. @@ -2234,7 +3161,7 @@ func encodeListChatsResponse(response ListChatsRes, w http.ResponseWriter) error return nil - case *CreateSessionTooManyRequestsHeaders: + case *GetAttachmentTooManyRequestsHeaders: w.Header().Set("Content-Type", "application/json; charset=utf-8") w.Header().Set("Access-Control-Expose-Headers", "Retry-After,X-Instance-Id,X-Request-Id") // Encoding response headers. @@ -2491,7 +3418,7 @@ func encodeListMessagesResponse(response ListMessagesRes, w http.ResponseWriter) return nil - case *CreateSessionUnauthorizedHeaders: + case *GetAttachmentUnauthorizedHeaders: w.Header().Set("Content-Type", "application/json; charset=utf-8") w.Header().Set("Access-Control-Expose-Headers", "Www-Authenticate,X-Instance-Id,X-Request-Id") // Encoding response headers. @@ -2647,7 +3574,7 @@ func encodeListMessagesResponse(response ListMessagesRes, w http.ResponseWriter) return nil - case *CreateSessionTooManyRequestsHeaders: + case *GetAttachmentTooManyRequestsHeaders: w.Header().Set("Content-Type", "application/json; charset=utf-8") w.Header().Set("Access-Control-Expose-Headers", "Retry-After,X-Instance-Id,X-Request-Id") // Encoding response headers. @@ -3200,7 +4127,7 @@ func encodeRegisterUserResponse(response RegisterUserRes, w http.ResponseWriter) return nil - case *CreateSessionTooManyRequestsHeaders: + case *GetAttachmentTooManyRequestsHeaders: w.Header().Set("Content-Type", "application/json; charset=utf-8") w.Header().Set("Access-Control-Expose-Headers", "Retry-After,X-Instance-Id,X-Request-Id") // Encoding response headers. @@ -3403,7 +4330,7 @@ func encodeRevokeSessionResponse(response RevokeSessionRes, w http.ResponseWrite return nil - case *CreateSessionUnauthorizedHeaders: + case *GetAttachmentUnauthorizedHeaders: w.Header().Set("Content-Type", "application/json; charset=utf-8") w.Header().Set("Access-Control-Expose-Headers", "Www-Authenticate,X-Instance-Id,X-Request-Id") // Encoding response headers. @@ -3465,7 +4392,7 @@ func encodeRevokeSessionResponse(response RevokeSessionRes, w http.ResponseWrite return nil - case *CreateSessionTooManyRequestsHeaders: + case *GetAttachmentTooManyRequestsHeaders: w.Header().Set("Content-Type", "application/json; charset=utf-8") w.Header().Set("Access-Control-Expose-Headers", "Retry-After,X-Instance-Id,X-Request-Id") // Encoding response headers. @@ -3625,3 +4552,463 @@ func encodeRevokeSessionResponse(response RevokeSessionRes, w http.ResponseWrite return errors.Errorf("unexpected response type: %T", response) } } + +func encodeUploadAttachmentResponse(response UploadAttachmentRes, w http.ResponseWriter) error { + switch response := response.(type) { + case *AttachmentHeaders: + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.Header().Set("Access-Control-Expose-Headers", "X-Instance-Id,X-Request-Id") + // Encoding response headers. + { + h := uri.NewHeaderEncoder(w.Header()) + // Encode "X-Instance-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Instance-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XInstanceID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Instance-Id header") + } + } + // Encode "X-Request-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Request-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XRequestID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Request-Id header") + } + } + } + w.WriteHeader(201) + + e := new(jx.Encoder) + response.Response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil + + case *UploadAttachmentBadRequest: + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.Header().Set("Access-Control-Expose-Headers", "X-Instance-Id,X-Request-Id") + // Encoding response headers. + { + h := uri.NewHeaderEncoder(w.Header()) + // Encode "X-Instance-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Instance-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XInstanceID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Instance-Id header") + } + } + // Encode "X-Request-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Request-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XRequestID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Request-Id header") + } + } + } + w.WriteHeader(400) + + e := new(jx.Encoder) + response.Response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil + + case *GetAttachmentUnauthorizedHeaders: + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.Header().Set("Access-Control-Expose-Headers", "Www-Authenticate,X-Instance-Id,X-Request-Id") + // Encoding response headers. + { + h := uri.NewHeaderEncoder(w.Header()) + // Encode "WWW-Authenticate" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "WWW-Authenticate", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.WWWAuthenticate.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode WWW-Authenticate header") + } + } + // Encode "X-Instance-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Instance-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XInstanceID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Instance-Id header") + } + } + // Encode "X-Request-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Request-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XRequestID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Request-Id header") + } + } + } + w.WriteHeader(401) + + e := new(jx.Encoder) + response.Response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil + + case *UploadAttachmentNotFound: + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.Header().Set("Access-Control-Expose-Headers", "X-Instance-Id,X-Request-Id") + // Encoding response headers. + { + h := uri.NewHeaderEncoder(w.Header()) + // Encode "X-Instance-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Instance-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XInstanceID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Instance-Id header") + } + } + // Encode "X-Request-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Request-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XRequestID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Request-Id header") + } + } + } + w.WriteHeader(404) + + e := new(jx.Encoder) + response.Response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil + + case *UploadAttachmentRequestEntityTooLarge: + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.Header().Set("Access-Control-Expose-Headers", "X-Instance-Id,X-Request-Id") + // Encoding response headers. + { + h := uri.NewHeaderEncoder(w.Header()) + // Encode "X-Instance-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Instance-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XInstanceID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Instance-Id header") + } + } + // Encode "X-Request-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Request-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XRequestID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Request-Id header") + } + } + } + w.WriteHeader(413) + + e := new(jx.Encoder) + response.Response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil + + case *UploadAttachmentUnsupportedMediaType: + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.Header().Set("Access-Control-Expose-Headers", "X-Instance-Id,X-Request-Id") + // Encoding response headers. + { + h := uri.NewHeaderEncoder(w.Header()) + // Encode "X-Instance-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Instance-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XInstanceID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Instance-Id header") + } + } + // Encode "X-Request-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Request-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XRequestID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Request-Id header") + } + } + } + w.WriteHeader(415) + + e := new(jx.Encoder) + response.Response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil + + case *GetAttachmentTooManyRequestsHeaders: + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.Header().Set("Access-Control-Expose-Headers", "Retry-After,X-Instance-Id,X-Request-Id") + // Encoding response headers. + { + h := uri.NewHeaderEncoder(w.Header()) + // Encode "Retry-After" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "Retry-After", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.RetryAfter.Get(); ok { + return e.EncodeValue(conv.IntToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode Retry-After header") + } + } + // Encode "X-Instance-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Instance-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XInstanceID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Instance-Id header") + } + } + // Encode "X-Request-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Request-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XRequestID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Request-Id header") + } + } + } + w.WriteHeader(429) + + e := new(jx.Encoder) + response.Response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil + + case *UploadAttachmentInternalServerError: + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.Header().Set("Access-Control-Expose-Headers", "X-Instance-Id,X-Request-Id") + // Encoding response headers. + { + h := uri.NewHeaderEncoder(w.Header()) + // Encode "X-Instance-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Instance-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XInstanceID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Instance-Id header") + } + } + // Encode "X-Request-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Request-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XRequestID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Request-Id header") + } + } + } + w.WriteHeader(500) + + e := new(jx.Encoder) + response.Response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil + + case *UploadAttachmentServiceUnavailable: + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.Header().Set("Access-Control-Expose-Headers", "X-Instance-Id,X-Request-Id") + // Encoding response headers. + { + h := uri.NewHeaderEncoder(w.Header()) + // Encode "X-Instance-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Instance-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XInstanceID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Instance-Id header") + } + } + // Encode "X-Request-Id" header. + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "X-Request-Id", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := response.XRequestID.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return errors.Wrap(err, "encode X-Request-Id header") + } + } + } + w.WriteHeader(503) + + e := new(jx.Encoder) + response.Response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil + + default: + return errors.Errorf("unexpected response type: %T", response) + } +} diff --git a/internal/transport/rest/internal/oas/oas_router_gen.go b/internal/transport/rest/internal/oas/oas_router_gen.go index a14efa17..a52fc994 100644 --- a/internal/transport/rest/internal/oas/oas_router_gen.go +++ b/internal/transport/rest/internal/oas/oas_router_gen.go @@ -11,10 +11,16 @@ import ( ) var ( + rn10AllowedHeaders = map[string]string{ + "GET": "Authorization", + } + rn11AllowedHeaders = map[string]string{ + "GET": "Authorization", + } rn6AllowedHeaders = map[string]string{ "POST": "Authorization", } - rn13AllowedHeaders = map[string]string{ + rn17AllowedHeaders = map[string]string{ "DELETE": "Authorization", } rn1AllowedHeaders = map[string]string{ @@ -24,11 +30,14 @@ var ( rn3AllowedHeaders = map[string]string{ "GET": "Authorization", } + rn19AllowedHeaders = map[string]string{ + "POST": "Authorization,Content-Type", + } rn4AllowedHeaders = map[string]string{ "GET": "Authorization", "POST": "Authorization,Content-Type,Idempotency-Key", } - rn12AllowedHeaders = map[string]string{ + rn16AllowedHeaders = map[string]string{ "POST": "Content-Type", } rn7AllowedHeaders = map[string]string{ @@ -99,47 +108,45 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { break } switch elem[0] { - case 'a': // Prefix: "auth/sessions" + case 'a': // Prefix: "a" - if l := len("auth/sessions"); len(elem) >= l && elem[0:l] == "auth/sessions" { + if l := len("a"); len(elem) >= l && elem[0:l] == "a" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleCreateSessionRequest([0]string{}, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "POST", - allowedHeaders: rn6AllowedHeaders, - acceptPost: "", - acceptPatch: "", - }) - } - - return + break } switch elem[0] { - case '/': // Prefix: "/current" + case 't': // Prefix: "ttachments/" - if l := len("/current"); len(elem) >= l && elem[0:l] == "/current" { + if l := len("ttachments/"); len(elem) >= l && elem[0:l] == "ttachments/" { elem = elem[l:] } else { break } + // Param: "attachment_id" + // Match until "/" + idx := strings.IndexByte(elem, '/') + if idx < 0 { + idx = len(elem) + } + args[0] = elem[:idx] + elem = elem[idx:] + if len(elem) == 0 { - // Leaf node. switch r.Method { - case "DELETE": - s.handleRevokeSessionRequest([0]string{}, elemIsEscaped, w, r) + case "GET": + s.handleGetAttachmentRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) default: s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "DELETE", - allowedHeaders: rn13AllowedHeaders, + allowedMethods: "GET", + allowedHeaders: rn10AllowedHeaders, acceptPost: "", acceptPatch: "", }) @@ -147,6 +154,86 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } + switch elem[0] { + case '/': // Prefix: "/content" + + if l := len("/content"); len(elem) >= l && elem[0:l] == "/content" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleDownloadAttachmentRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: rn11AllowedHeaders, + acceptPost: "", + acceptPatch: "", + }) + } + + return + } + + } + + case 'u': // Prefix: "uth/sessions" + + if l := len("uth/sessions"); len(elem) >= l && elem[0:l] == "uth/sessions" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleCreateSessionRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "POST", + allowedHeaders: rn6AllowedHeaders, + acceptPost: "", + acceptPatch: "", + }) + } + + return + } + switch elem[0] { + case '/': // Prefix: "/current" + + if l := len("/current"); len(elem) >= l && elem[0:l] == "/current" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "DELETE": + s.handleRevokeSessionRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "DELETE", + allowedHeaders: rn17AllowedHeaders, + acceptPost: "", + acceptPatch: "", + }) + } + + return + } + + } } @@ -211,35 +298,76 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } switch elem[0] { - case '/': // Prefix: "/messages" + case '/': // Prefix: "/" - if l := len("/messages"); len(elem) >= l && elem[0:l] == "/messages" { + if l := len("/"); len(elem) >= l && elem[0:l] == "/" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleListMessagesRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) - case "POST": - s.handleCreateMessageRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET,POST", - allowedHeaders: rn4AllowedHeaders, - acceptPost: "application/json", - acceptPatch: "", - }) + break + } + switch elem[0] { + case 'a': // Prefix: "attachments" + + if l := len("attachments"); len(elem) >= l && elem[0:l] == "attachments" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleUploadAttachmentRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "POST", + allowedHeaders: rn19AllowedHeaders, + acceptPost: "image/jpeg,image/png", + acceptPatch: "", + }) + } + + return + } + + case 'm': // Prefix: "messages" + + if l := len("messages"); len(elem) >= l && elem[0:l] == "messages" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleListMessagesRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + case "POST": + s.handleCreateMessageRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET,POST", + allowedHeaders: rn4AllowedHeaders, + acceptPost: "application/json", + acceptPatch: "", + }) + } + + return } - return } } @@ -261,7 +389,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { default: s.notAllowed(w, r, notAllowedParams{ allowedMethods: "POST", - allowedHeaders: rn12AllowedHeaders, + allowedHeaders: rn16AllowedHeaders, acceptPost: "application/json", acceptPatch: "", }) @@ -475,47 +603,94 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { break } switch elem[0] { - case 'a': // Prefix: "auth/sessions" + case 'a': // Prefix: "a" - if l := len("auth/sessions"); len(elem) >= l && elem[0:l] == "auth/sessions" { + if l := len("a"); len(elem) >= l && elem[0:l] == "a" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch method { - case "POST": - r.name = CreateSessionOperation - r.summary = "Вход: Basic username:password; выдаёт сессию" - r.operationID = "createSession" - r.operationGroup = "" - r.pathPattern = "/api/v1/auth/sessions" - r.args = args - r.count = 0 - return r, true - default: - return - } + break } switch elem[0] { - case '/': // Prefix: "/current" + case 't': // Prefix: "ttachments/" - if l := len("/current"); len(elem) >= l && elem[0:l] == "/current" { + if l := len("ttachments/"); len(elem) >= l && elem[0:l] == "ttachments/" { + elem = elem[l:] + } else { + break + } + + // Param: "attachment_id" + // Match until "/" + idx := strings.IndexByte(elem, '/') + if idx < 0 { + idx = len(elem) + } + args[0] = elem[:idx] + elem = elem[idx:] + + if len(elem) == 0 { + switch method { + case "GET": + r.name = GetAttachmentOperation + r.summary = "Метаданные вложения, доступ участникам чата" + r.operationID = "getAttachment" + r.operationGroup = "" + r.pathPattern = "/api/v1/attachments/{attachment_id}" + r.args = args + r.count = 1 + return r, true + default: + return + } + } + switch elem[0] { + case '/': // Prefix: "/content" + + if l := len("/content"); len(elem) >= l && elem[0:l] == "/content" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = DownloadAttachmentOperation + r.summary = "Скачать байты через авторизованный API" + r.operationID = "downloadAttachment" + r.operationGroup = "" + r.pathPattern = "/api/v1/attachments/{attachment_id}/content" + r.args = args + r.count = 1 + return r, true + default: + return + } + } + + } + + case 'u': // Prefix: "uth/sessions" + + if l := len("uth/sessions"); len(elem) >= l && elem[0:l] == "uth/sessions" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. switch method { - case "DELETE": - r.name = RevokeSessionOperation - r.summary = "Отозвать текущую сессию" - r.operationID = "revokeSession" + case "POST": + r.name = CreateSessionOperation + r.summary = "Вход: Basic username:password; выдаёт сессию" + r.operationID = "createSession" r.operationGroup = "" - r.pathPattern = "/api/v1/auth/sessions/current" + r.pathPattern = "/api/v1/auth/sessions" r.args = args r.count = 0 return r, true @@ -523,6 +698,33 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { return } } + switch elem[0] { + case '/': // Prefix: "/current" + + if l := len("/current"); len(elem) >= l && elem[0:l] == "/current" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch method { + case "DELETE": + r.name = RevokeSessionOperation + r.summary = "Отозвать текущую сессию" + r.operationID = "revokeSession" + r.operationGroup = "" + r.pathPattern = "/api/v1/auth/sessions/current" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + + } } @@ -592,38 +794,77 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { } } switch elem[0] { - case '/': // Prefix: "/messages" + case '/': // Prefix: "/" - if l := len("/messages"); len(elem) >= l && elem[0:l] == "/messages" { + if l := len("/"); len(elem) >= l && elem[0:l] == "/" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. - switch method { - case "GET": - r.name = ListMessagesOperation - r.summary = "Сообщения по (created_at, id) по возрастанию" - r.operationID = "listMessages" - r.operationGroup = "" - r.pathPattern = "/api/v1/chats/{chat_id}/messages" - r.args = args - r.count = 1 - return r, true - case "POST": - r.name = CreateMessageOperation - r.summary = "Отправить сообщение" - r.operationID = "createMessage" - r.operationGroup = "" - r.pathPattern = "/api/v1/chats/{chat_id}/messages" - r.args = args - r.count = 1 - return r, true - default: - return + break + } + switch elem[0] { + case 'a': // Prefix: "attachments" + + if l := len("attachments"); len(elem) >= l && elem[0:l] == "attachments" { + elem = elem[l:] + } else { + break } + + if len(elem) == 0 { + // Leaf node. + switch method { + case "POST": + r.name = UploadAttachmentOperation + r.summary = "Принять один PNG/JPEG, до 10 MiB" + r.operationID = "uploadAttachment" + r.operationGroup = "" + r.pathPattern = "/api/v1/chats/{chat_id}/attachments" + r.args = args + r.count = 1 + return r, true + default: + return + } + } + + case 'm': // Prefix: "messages" + + if l := len("messages"); len(elem) >= l && elem[0:l] == "messages" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = ListMessagesOperation + r.summary = "Сообщения по (created_at, id) по возрастанию" + r.operationID = "listMessages" + r.operationGroup = "" + r.pathPattern = "/api/v1/chats/{chat_id}/messages" + r.args = args + r.count = 1 + return r, true + case "POST": + r.name = CreateMessageOperation + r.summary = "Отправить сообщение" + r.operationID = "createMessage" + r.operationGroup = "" + r.pathPattern = "/api/v1/chats/{chat_id}/messages" + r.args = args + r.count = 1 + return r, true + default: + return + } + } + } } diff --git a/internal/transport/rest/internal/oas/oas_schemas_gen.go b/internal/transport/rest/internal/oas/oas_schemas_gen.go index 75f4a280..47002592 100644 --- a/internal/transport/rest/internal/oas/oas_schemas_gen.go +++ b/internal/transport/rest/internal/oas/oas_schemas_gen.go @@ -3,12 +3,264 @@ package oas import ( + "io" "time" "github.com/go-faster/errors" "github.com/google/uuid" ) +// Ref: #/components/schemas/Attachment +type Attachment struct { + ChatID uuid.UUID `json:"chat_id"` + ContentType AttachmentContentType `json:"content_type"` + CreatedAt time.Time `json:"created_at"` + ErrorCode NilString `json:"error_code"` + Filename string `json:"filename"` + ID uuid.UUID `json:"id"` + OwnerID uuid.UUID `json:"owner_id"` + SHA256 string `json:"sha256"` + SizeBytes int `json:"size_bytes"` + Status AttachmentStatus `json:"status"` + UpdatedAt time.Time `json:"updated_at"` + Variants []Variant `json:"variants"` +} + +// GetChatID returns the value of ChatID. +func (s *Attachment) GetChatID() uuid.UUID { + return s.ChatID +} + +// GetContentType returns the value of ContentType. +func (s *Attachment) GetContentType() AttachmentContentType { + return s.ContentType +} + +// GetCreatedAt returns the value of CreatedAt. +func (s *Attachment) GetCreatedAt() time.Time { + return s.CreatedAt +} + +// GetErrorCode returns the value of ErrorCode. +func (s *Attachment) GetErrorCode() NilString { + return s.ErrorCode +} + +// GetFilename returns the value of Filename. +func (s *Attachment) GetFilename() string { + return s.Filename +} + +// GetID returns the value of ID. +func (s *Attachment) GetID() uuid.UUID { + return s.ID +} + +// GetOwnerID returns the value of OwnerID. +func (s *Attachment) GetOwnerID() uuid.UUID { + return s.OwnerID +} + +// GetSHA256 returns the value of SHA256. +func (s *Attachment) GetSHA256() string { + return s.SHA256 +} + +// GetSizeBytes returns the value of SizeBytes. +func (s *Attachment) GetSizeBytes() int { + return s.SizeBytes +} + +// GetStatus returns the value of Status. +func (s *Attachment) GetStatus() AttachmentStatus { + return s.Status +} + +// GetUpdatedAt returns the value of UpdatedAt. +func (s *Attachment) GetUpdatedAt() time.Time { + return s.UpdatedAt +} + +// GetVariants returns the value of Variants. +func (s *Attachment) GetVariants() []Variant { + return s.Variants +} + +// SetChatID sets the value of ChatID. +func (s *Attachment) SetChatID(val uuid.UUID) { + s.ChatID = val +} + +// SetContentType sets the value of ContentType. +func (s *Attachment) SetContentType(val AttachmentContentType) { + s.ContentType = val +} + +// SetCreatedAt sets the value of CreatedAt. +func (s *Attachment) SetCreatedAt(val time.Time) { + s.CreatedAt = val +} + +// SetErrorCode sets the value of ErrorCode. +func (s *Attachment) SetErrorCode(val NilString) { + s.ErrorCode = val +} + +// SetFilename sets the value of Filename. +func (s *Attachment) SetFilename(val string) { + s.Filename = val +} + +// SetID sets the value of ID. +func (s *Attachment) SetID(val uuid.UUID) { + s.ID = val +} + +// SetOwnerID sets the value of OwnerID. +func (s *Attachment) SetOwnerID(val uuid.UUID) { + s.OwnerID = val +} + +// SetSHA256 sets the value of SHA256. +func (s *Attachment) SetSHA256(val string) { + s.SHA256 = val +} + +// SetSizeBytes sets the value of SizeBytes. +func (s *Attachment) SetSizeBytes(val int) { + s.SizeBytes = val +} + +// SetStatus sets the value of Status. +func (s *Attachment) SetStatus(val AttachmentStatus) { + s.Status = val +} + +// SetUpdatedAt sets the value of UpdatedAt. +func (s *Attachment) SetUpdatedAt(val time.Time) { + s.UpdatedAt = val +} + +// SetVariants sets the value of Variants. +func (s *Attachment) SetVariants(val []Variant) { + s.Variants = val +} + +type AttachmentContentType string + +const ( + AttachmentContentTypeImagePNG AttachmentContentType = "image/png" + AttachmentContentTypeImageJpeg AttachmentContentType = "image/jpeg" +) + +// AllValues returns all AttachmentContentType values. +func (AttachmentContentType) AllValues() []AttachmentContentType { + return []AttachmentContentType{ + AttachmentContentTypeImagePNG, + AttachmentContentTypeImageJpeg, + } +} + +// MarshalText implements encoding.TextMarshaler. +func (s AttachmentContentType) MarshalText() ([]byte, error) { + switch s { + case AttachmentContentTypeImagePNG: + return []byte(s), nil + case AttachmentContentTypeImageJpeg: + return []byte(s), nil + default: + return nil, errors.Errorf("invalid value: %q", s) + } +} + +// UnmarshalText implements encoding.TextUnmarshaler. +func (s *AttachmentContentType) UnmarshalText(data []byte) error { + switch AttachmentContentType(data) { + case AttachmentContentTypeImagePNG: + *s = AttachmentContentTypeImagePNG + return nil + case AttachmentContentTypeImageJpeg: + *s = AttachmentContentTypeImageJpeg + return nil + default: + return errors.Errorf("invalid value: %q", data) + } +} + +// AttachmentHeaders wraps Attachment with response headers. +type AttachmentHeaders struct { + XInstanceID OptString + XRequestID OptString + Response Attachment +} + +// GetXInstanceID returns the value of XInstanceID. +func (s *AttachmentHeaders) GetXInstanceID() OptString { + return s.XInstanceID +} + +// GetXRequestID returns the value of XRequestID. +func (s *AttachmentHeaders) GetXRequestID() OptString { + return s.XRequestID +} + +// GetResponse returns the value of Response. +func (s *AttachmentHeaders) GetResponse() Attachment { + return s.Response +} + +// SetXInstanceID sets the value of XInstanceID. +func (s *AttachmentHeaders) SetXInstanceID(val OptString) { + s.XInstanceID = val +} + +// SetXRequestID sets the value of XRequestID. +func (s *AttachmentHeaders) SetXRequestID(val OptString) { + s.XRequestID = val +} + +// SetResponse sets the value of Response. +func (s *AttachmentHeaders) SetResponse(val Attachment) { + s.Response = val +} + +func (*AttachmentHeaders) getAttachmentRes() {} +func (*AttachmentHeaders) uploadAttachmentRes() {} + +type AttachmentStatus string + +const ( + AttachmentStatusReady AttachmentStatus = "ready" +) + +// AllValues returns all AttachmentStatus values. +func (AttachmentStatus) AllValues() []AttachmentStatus { + return []AttachmentStatus{ + AttachmentStatusReady, + } +} + +// MarshalText implements encoding.TextMarshaler. +func (s AttachmentStatus) MarshalText() ([]byte, error) { + switch s { + case AttachmentStatusReady: + return []byte(s), nil + default: + return nil, errors.Errorf("invalid value: %q", s) + } +} + +// UnmarshalText implements encoding.TextUnmarshaler. +func (s *AttachmentStatus) UnmarshalText(data []byte) error { + switch AttachmentStatus(data) { + case AttachmentStatusReady: + *s = AttachmentStatusReady + return nil + default: + return errors.Errorf("invalid value: %q", data) + } +} + type BasicAuth struct { Username string Password string @@ -72,25 +324,10 @@ func (s *BearerAuth) SetRoles(val []string) { // Ref: #/components/schemas/Chat type Chat struct { - ID uuid.UUID `json:"id"` - Title string `json:"title"` - MemberIds []uuid.UUID `json:"member_ids"` CreatedAt time.Time `json:"created_at"` -} - -// GetID returns the value of ID. -func (s *Chat) GetID() uuid.UUID { - return s.ID -} - -// GetTitle returns the value of Title. -func (s *Chat) GetTitle() string { - return s.Title -} - -// GetMemberIds returns the value of MemberIds. -func (s *Chat) GetMemberIds() []uuid.UUID { - return s.MemberIds + ID uuid.UUID `json:"id"` + MemberIds []uuid.UUID `json:"member_ids"` + Title string `json:"title"` } // GetCreatedAt returns the value of CreatedAt. @@ -98,24 +335,39 @@ func (s *Chat) GetCreatedAt() time.Time { return s.CreatedAt } +// GetID returns the value of ID. +func (s *Chat) GetID() uuid.UUID { + return s.ID +} + +// GetMemberIds returns the value of MemberIds. +func (s *Chat) GetMemberIds() []uuid.UUID { + return s.MemberIds +} + +// GetTitle returns the value of Title. +func (s *Chat) GetTitle() string { + return s.Title +} + +// SetCreatedAt sets the value of CreatedAt. +func (s *Chat) SetCreatedAt(val time.Time) { + s.CreatedAt = val +} + // SetID sets the value of ID. func (s *Chat) SetID(val uuid.UUID) { s.ID = val } -// SetTitle sets the value of Title. -func (s *Chat) SetTitle(val string) { - s.Title = val -} - // SetMemberIds sets the value of MemberIds. func (s *Chat) SetMemberIds(val []uuid.UUID) { s.MemberIds = val } -// SetCreatedAt sets the value of CreatedAt. -func (s *Chat) SetCreatedAt(val time.Time) { - s.CreatedAt = val +// SetTitle sets the value of Title. +func (s *Chat) SetTitle(val string) { + s.Title = val } // ChatHeaders wraps Chat with response headers. @@ -225,13 +477,8 @@ func (*ChatPageHeaders) listChatsRes() {} // Ref: #/components/schemas/CreateChat type CreateChat struct { - Title string `json:"title"` MemberIds []uuid.UUID `json:"member_ids"` -} - -// GetTitle returns the value of Title. -func (s *CreateChat) GetTitle() string { - return s.Title + Title string `json:"title"` } // GetMemberIds returns the value of MemberIds. @@ -239,9 +486,9 @@ func (s *CreateChat) GetMemberIds() []uuid.UUID { return s.MemberIds } -// SetTitle sets the value of Title. -func (s *CreateChat) SetTitle(val string) { - s.Title = val +// GetTitle returns the value of Title. +func (s *CreateChat) GetTitle() string { + return s.Title } // SetMemberIds sets the value of MemberIds. @@ -249,6 +496,11 @@ func (s *CreateChat) SetMemberIds(val []uuid.UUID) { s.MemberIds = val } +// SetTitle sets the value of Title. +func (s *CreateChat) SetTitle(val string) { + s.Title = val +} + type CreateChatBadRequest ErrorHeaders func (*CreateChatBadRequest) createChatRes() {} @@ -271,7 +523,13 @@ func (*CreateChatServiceUnavailable) createChatRes() {} // Ref: #/components/schemas/CreateMessage type CreateMessage struct { - Text string `json:"text"` + AttachmentIds []uuid.UUID `json:"attachment_ids"` + Text string `json:"text"` +} + +// GetAttachmentIds returns the value of AttachmentIds. +func (s *CreateMessage) GetAttachmentIds() []uuid.UUID { + return s.AttachmentIds } // GetText returns the value of Text. @@ -279,6 +537,11 @@ func (s *CreateMessage) GetText() string { return s.Text } +// SetAttachmentIds sets the value of AttachmentIds. +func (s *CreateMessage) SetAttachmentIds(val []uuid.UUID) { + s.AttachmentIds = val +} + // SetText sets the value of Text. func (s *CreateMessage) SetText(val string) { s.Text = val @@ -316,131 +579,11 @@ type CreateSessionServiceUnavailable ErrorHeaders func (*CreateSessionServiceUnavailable) createSessionRes() {} -// CreateSessionTooManyRequestsHeaders wraps Error with response headers. -type CreateSessionTooManyRequestsHeaders struct { - RetryAfter OptInt - XInstanceID OptString - XRequestID OptString - Response Error -} - -// GetRetryAfter returns the value of RetryAfter. -func (s *CreateSessionTooManyRequestsHeaders) GetRetryAfter() OptInt { - return s.RetryAfter -} - -// GetXInstanceID returns the value of XInstanceID. -func (s *CreateSessionTooManyRequestsHeaders) GetXInstanceID() OptString { - return s.XInstanceID -} - -// GetXRequestID returns the value of XRequestID. -func (s *CreateSessionTooManyRequestsHeaders) GetXRequestID() OptString { - return s.XRequestID -} - -// GetResponse returns the value of Response. -func (s *CreateSessionTooManyRequestsHeaders) GetResponse() Error { - return s.Response -} - -// SetRetryAfter sets the value of RetryAfter. -func (s *CreateSessionTooManyRequestsHeaders) SetRetryAfter(val OptInt) { - s.RetryAfter = val -} - -// SetXInstanceID sets the value of XInstanceID. -func (s *CreateSessionTooManyRequestsHeaders) SetXInstanceID(val OptString) { - s.XInstanceID = val -} - -// SetXRequestID sets the value of XRequestID. -func (s *CreateSessionTooManyRequestsHeaders) SetXRequestID(val OptString) { - s.XRequestID = val -} - -// SetResponse sets the value of Response. -func (s *CreateSessionTooManyRequestsHeaders) SetResponse(val Error) { - s.Response = val -} - -func (*CreateSessionTooManyRequestsHeaders) createChatRes() {} -func (*CreateSessionTooManyRequestsHeaders) createMessageRes() {} -func (*CreateSessionTooManyRequestsHeaders) createSessionRes() {} -func (*CreateSessionTooManyRequestsHeaders) currentUserRes() {} -func (*CreateSessionTooManyRequestsHeaders) getChatRes() {} -func (*CreateSessionTooManyRequestsHeaders) listChatsRes() {} -func (*CreateSessionTooManyRequestsHeaders) listMessagesRes() {} -func (*CreateSessionTooManyRequestsHeaders) registerUserRes() {} -func (*CreateSessionTooManyRequestsHeaders) revokeSessionRes() {} - -// CreateSessionUnauthorizedHeaders wraps Error with response headers. -type CreateSessionUnauthorizedHeaders struct { - WWWAuthenticate OptString - XInstanceID OptString - XRequestID OptString - Response Error -} - -// GetWWWAuthenticate returns the value of WWWAuthenticate. -func (s *CreateSessionUnauthorizedHeaders) GetWWWAuthenticate() OptString { - return s.WWWAuthenticate -} - -// GetXInstanceID returns the value of XInstanceID. -func (s *CreateSessionUnauthorizedHeaders) GetXInstanceID() OptString { - return s.XInstanceID -} - -// GetXRequestID returns the value of XRequestID. -func (s *CreateSessionUnauthorizedHeaders) GetXRequestID() OptString { - return s.XRequestID -} - -// GetResponse returns the value of Response. -func (s *CreateSessionUnauthorizedHeaders) GetResponse() Error { - return s.Response -} - -// SetWWWAuthenticate sets the value of WWWAuthenticate. -func (s *CreateSessionUnauthorizedHeaders) SetWWWAuthenticate(val OptString) { - s.WWWAuthenticate = val -} - -// SetXInstanceID sets the value of XInstanceID. -func (s *CreateSessionUnauthorizedHeaders) SetXInstanceID(val OptString) { - s.XInstanceID = val -} - -// SetXRequestID sets the value of XRequestID. -func (s *CreateSessionUnauthorizedHeaders) SetXRequestID(val OptString) { - s.XRequestID = val -} - -// SetResponse sets the value of Response. -func (s *CreateSessionUnauthorizedHeaders) SetResponse(val Error) { - s.Response = val -} - -func (*CreateSessionUnauthorizedHeaders) createChatRes() {} -func (*CreateSessionUnauthorizedHeaders) createMessageRes() {} -func (*CreateSessionUnauthorizedHeaders) createSessionRes() {} -func (*CreateSessionUnauthorizedHeaders) currentUserRes() {} -func (*CreateSessionUnauthorizedHeaders) getChatRes() {} -func (*CreateSessionUnauthorizedHeaders) listChatsRes() {} -func (*CreateSessionUnauthorizedHeaders) listMessagesRes() {} -func (*CreateSessionUnauthorizedHeaders) revokeSessionRes() {} - // Ref: #/components/schemas/CreateUser type CreateUser struct { - Username string `json:"username"` DisplayName string `json:"display_name"` Password string `json:"password"` -} - -// GetUsername returns the value of Username. -func (s *CreateUser) GetUsername() string { - return s.Username + Username string `json:"username"` } // GetDisplayName returns the value of DisplayName. @@ -453,9 +596,9 @@ func (s *CreateUser) GetPassword() string { return s.Password } -// SetUsername sets the value of Username. -func (s *CreateUser) SetUsername(val string) { - s.Username = val +// GetUsername returns the value of Username. +func (s *CreateUser) GetUsername() string { + return s.Username } // SetDisplayName sets the value of DisplayName. @@ -468,6 +611,11 @@ func (s *CreateUser) SetPassword(val string) { s.Password = val } +// SetUsername sets the value of Username. +func (s *CreateUser) SetUsername(val string) { + s.Username = val +} + type CurrentUserBadRequest ErrorHeaders func (*CurrentUserBadRequest) currentUserRes() {} @@ -488,6 +636,219 @@ type CurrentUserServiceUnavailable ErrorHeaders func (*CurrentUserServiceUnavailable) currentUserRes() {} +type DownloadAttachmentBadRequest ErrorHeaders + +func (*DownloadAttachmentBadRequest) downloadAttachmentRes() {} + +type DownloadAttachmentConflict ErrorHeaders + +func (*DownloadAttachmentConflict) downloadAttachmentRes() {} + +type DownloadAttachmentInternalServerError ErrorHeaders + +func (*DownloadAttachmentInternalServerError) downloadAttachmentRes() {} + +type DownloadAttachmentNotFound ErrorHeaders + +func (*DownloadAttachmentNotFound) downloadAttachmentRes() {} + +type DownloadAttachmentOKImageJpeg struct { + Data io.Reader +} + +// Read reads data from the Data reader. +// +// Kept to satisfy the io.Reader interface. +func (s DownloadAttachmentOKImageJpeg) Read(p []byte) (n int, err error) { + if s.Data == nil { + return 0, io.EOF + } + return s.Data.Read(p) +} + +// DownloadAttachmentOKImageJpegHeaders wraps DownloadAttachmentOKImageJpeg with response headers. +type DownloadAttachmentOKImageJpegHeaders struct { + XInstanceID OptString + XRequestID OptString + Response DownloadAttachmentOKImageJpeg +} + +// GetXInstanceID returns the value of XInstanceID. +func (s *DownloadAttachmentOKImageJpegHeaders) GetXInstanceID() OptString { + return s.XInstanceID +} + +// GetXRequestID returns the value of XRequestID. +func (s *DownloadAttachmentOKImageJpegHeaders) GetXRequestID() OptString { + return s.XRequestID +} + +// GetResponse returns the value of Response. +func (s *DownloadAttachmentOKImageJpegHeaders) GetResponse() DownloadAttachmentOKImageJpeg { + return s.Response +} + +// SetXInstanceID sets the value of XInstanceID. +func (s *DownloadAttachmentOKImageJpegHeaders) SetXInstanceID(val OptString) { + s.XInstanceID = val +} + +// SetXRequestID sets the value of XRequestID. +func (s *DownloadAttachmentOKImageJpegHeaders) SetXRequestID(val OptString) { + s.XRequestID = val +} + +// SetResponse sets the value of Response. +func (s *DownloadAttachmentOKImageJpegHeaders) SetResponse(val DownloadAttachmentOKImageJpeg) { + s.Response = val +} + +func (*DownloadAttachmentOKImageJpegHeaders) downloadAttachmentRes() {} + +type DownloadAttachmentOKImagePNG struct { + Data io.Reader +} + +// Read reads data from the Data reader. +// +// Kept to satisfy the io.Reader interface. +func (s DownloadAttachmentOKImagePNG) Read(p []byte) (n int, err error) { + if s.Data == nil { + return 0, io.EOF + } + return s.Data.Read(p) +} + +// DownloadAttachmentOKImagePNGHeaders wraps DownloadAttachmentOKImagePNG with response headers. +type DownloadAttachmentOKImagePNGHeaders struct { + XInstanceID OptString + XRequestID OptString + Response DownloadAttachmentOKImagePNG +} + +// GetXInstanceID returns the value of XInstanceID. +func (s *DownloadAttachmentOKImagePNGHeaders) GetXInstanceID() OptString { + return s.XInstanceID +} + +// GetXRequestID returns the value of XRequestID. +func (s *DownloadAttachmentOKImagePNGHeaders) GetXRequestID() OptString { + return s.XRequestID +} + +// GetResponse returns the value of Response. +func (s *DownloadAttachmentOKImagePNGHeaders) GetResponse() DownloadAttachmentOKImagePNG { + return s.Response +} + +// SetXInstanceID sets the value of XInstanceID. +func (s *DownloadAttachmentOKImagePNGHeaders) SetXInstanceID(val OptString) { + s.XInstanceID = val +} + +// SetXRequestID sets the value of XRequestID. +func (s *DownloadAttachmentOKImagePNGHeaders) SetXRequestID(val OptString) { + s.XRequestID = val +} + +// SetResponse sets the value of Response. +func (s *DownloadAttachmentOKImagePNGHeaders) SetResponse(val DownloadAttachmentOKImagePNG) { + s.Response = val +} + +func (*DownloadAttachmentOKImagePNGHeaders) downloadAttachmentRes() {} + +type DownloadAttachmentOKImageWEBP struct { + Data io.Reader +} + +// Read reads data from the Data reader. +// +// Kept to satisfy the io.Reader interface. +func (s DownloadAttachmentOKImageWEBP) Read(p []byte) (n int, err error) { + if s.Data == nil { + return 0, io.EOF + } + return s.Data.Read(p) +} + +// DownloadAttachmentOKImageWEBPHeaders wraps DownloadAttachmentOKImageWEBP with response headers. +type DownloadAttachmentOKImageWEBPHeaders struct { + XInstanceID OptString + XRequestID OptString + Response DownloadAttachmentOKImageWEBP +} + +// GetXInstanceID returns the value of XInstanceID. +func (s *DownloadAttachmentOKImageWEBPHeaders) GetXInstanceID() OptString { + return s.XInstanceID +} + +// GetXRequestID returns the value of XRequestID. +func (s *DownloadAttachmentOKImageWEBPHeaders) GetXRequestID() OptString { + return s.XRequestID +} + +// GetResponse returns the value of Response. +func (s *DownloadAttachmentOKImageWEBPHeaders) GetResponse() DownloadAttachmentOKImageWEBP { + return s.Response +} + +// SetXInstanceID sets the value of XInstanceID. +func (s *DownloadAttachmentOKImageWEBPHeaders) SetXInstanceID(val OptString) { + s.XInstanceID = val +} + +// SetXRequestID sets the value of XRequestID. +func (s *DownloadAttachmentOKImageWEBPHeaders) SetXRequestID(val OptString) { + s.XRequestID = val +} + +// SetResponse sets the value of Response. +func (s *DownloadAttachmentOKImageWEBPHeaders) SetResponse(val DownloadAttachmentOKImageWEBP) { + s.Response = val +} + +func (*DownloadAttachmentOKImageWEBPHeaders) downloadAttachmentRes() {} + +type DownloadAttachmentServiceUnavailable ErrorHeaders + +func (*DownloadAttachmentServiceUnavailable) downloadAttachmentRes() {} + +type DownloadAttachmentVariant string + +const ( + DownloadAttachmentVariantOriginal DownloadAttachmentVariant = "original" +) + +// AllValues returns all DownloadAttachmentVariant values. +func (DownloadAttachmentVariant) AllValues() []DownloadAttachmentVariant { + return []DownloadAttachmentVariant{ + DownloadAttachmentVariantOriginal, + } +} + +// MarshalText implements encoding.TextMarshaler. +func (s DownloadAttachmentVariant) MarshalText() ([]byte, error) { + switch s { + case DownloadAttachmentVariantOriginal: + return []byte(s), nil + default: + return nil, errors.Errorf("invalid value: %q", s) + } +} + +// UnmarshalText implements encoding.TextUnmarshaler. +func (s *DownloadAttachmentVariant) UnmarshalText(data []byte) error { + switch DownloadAttachmentVariant(data) { + case DownloadAttachmentVariantOriginal: + *s = DownloadAttachmentVariantOriginal + return nil + default: + return errors.Errorf("invalid value: %q", data) + } +} + // Ref: #/components/schemas/Error type Error struct { Error ErrorError `json:"error"` @@ -668,6 +1029,147 @@ func (s *ErrorHeaders) SetResponse(val Error) { func (*ErrorHeaders) livenessRes() {} +type GetAttachmentBadRequest ErrorHeaders + +func (*GetAttachmentBadRequest) getAttachmentRes() {} + +type GetAttachmentConflict ErrorHeaders + +func (*GetAttachmentConflict) getAttachmentRes() {} + +type GetAttachmentInternalServerError ErrorHeaders + +func (*GetAttachmentInternalServerError) getAttachmentRes() {} + +type GetAttachmentNotFound ErrorHeaders + +func (*GetAttachmentNotFound) getAttachmentRes() {} + +type GetAttachmentServiceUnavailable ErrorHeaders + +func (*GetAttachmentServiceUnavailable) getAttachmentRes() {} + +// GetAttachmentTooManyRequestsHeaders wraps Error with response headers. +type GetAttachmentTooManyRequestsHeaders struct { + RetryAfter OptInt + XInstanceID OptString + XRequestID OptString + Response Error +} + +// GetRetryAfter returns the value of RetryAfter. +func (s *GetAttachmentTooManyRequestsHeaders) GetRetryAfter() OptInt { + return s.RetryAfter +} + +// GetXInstanceID returns the value of XInstanceID. +func (s *GetAttachmentTooManyRequestsHeaders) GetXInstanceID() OptString { + return s.XInstanceID +} + +// GetXRequestID returns the value of XRequestID. +func (s *GetAttachmentTooManyRequestsHeaders) GetXRequestID() OptString { + return s.XRequestID +} + +// GetResponse returns the value of Response. +func (s *GetAttachmentTooManyRequestsHeaders) GetResponse() Error { + return s.Response +} + +// SetRetryAfter sets the value of RetryAfter. +func (s *GetAttachmentTooManyRequestsHeaders) SetRetryAfter(val OptInt) { + s.RetryAfter = val +} + +// SetXInstanceID sets the value of XInstanceID. +func (s *GetAttachmentTooManyRequestsHeaders) SetXInstanceID(val OptString) { + s.XInstanceID = val +} + +// SetXRequestID sets the value of XRequestID. +func (s *GetAttachmentTooManyRequestsHeaders) SetXRequestID(val OptString) { + s.XRequestID = val +} + +// SetResponse sets the value of Response. +func (s *GetAttachmentTooManyRequestsHeaders) SetResponse(val Error) { + s.Response = val +} + +func (*GetAttachmentTooManyRequestsHeaders) createChatRes() {} +func (*GetAttachmentTooManyRequestsHeaders) createMessageRes() {} +func (*GetAttachmentTooManyRequestsHeaders) createSessionRes() {} +func (*GetAttachmentTooManyRequestsHeaders) currentUserRes() {} +func (*GetAttachmentTooManyRequestsHeaders) downloadAttachmentRes() {} +func (*GetAttachmentTooManyRequestsHeaders) getAttachmentRes() {} +func (*GetAttachmentTooManyRequestsHeaders) getChatRes() {} +func (*GetAttachmentTooManyRequestsHeaders) listChatsRes() {} +func (*GetAttachmentTooManyRequestsHeaders) listMessagesRes() {} +func (*GetAttachmentTooManyRequestsHeaders) registerUserRes() {} +func (*GetAttachmentTooManyRequestsHeaders) revokeSessionRes() {} +func (*GetAttachmentTooManyRequestsHeaders) uploadAttachmentRes() {} + +// GetAttachmentUnauthorizedHeaders wraps Error with response headers. +type GetAttachmentUnauthorizedHeaders struct { + WWWAuthenticate OptString + XInstanceID OptString + XRequestID OptString + Response Error +} + +// GetWWWAuthenticate returns the value of WWWAuthenticate. +func (s *GetAttachmentUnauthorizedHeaders) GetWWWAuthenticate() OptString { + return s.WWWAuthenticate +} + +// GetXInstanceID returns the value of XInstanceID. +func (s *GetAttachmentUnauthorizedHeaders) GetXInstanceID() OptString { + return s.XInstanceID +} + +// GetXRequestID returns the value of XRequestID. +func (s *GetAttachmentUnauthorizedHeaders) GetXRequestID() OptString { + return s.XRequestID +} + +// GetResponse returns the value of Response. +func (s *GetAttachmentUnauthorizedHeaders) GetResponse() Error { + return s.Response +} + +// SetWWWAuthenticate sets the value of WWWAuthenticate. +func (s *GetAttachmentUnauthorizedHeaders) SetWWWAuthenticate(val OptString) { + s.WWWAuthenticate = val +} + +// SetXInstanceID sets the value of XInstanceID. +func (s *GetAttachmentUnauthorizedHeaders) SetXInstanceID(val OptString) { + s.XInstanceID = val +} + +// SetXRequestID sets the value of XRequestID. +func (s *GetAttachmentUnauthorizedHeaders) SetXRequestID(val OptString) { + s.XRequestID = val +} + +// SetResponse sets the value of Response. +func (s *GetAttachmentUnauthorizedHeaders) SetResponse(val Error) { + s.Response = val +} + +func (*GetAttachmentUnauthorizedHeaders) createChatRes() {} +func (*GetAttachmentUnauthorizedHeaders) createMessageRes() {} +func (*GetAttachmentUnauthorizedHeaders) createSessionRes() {} +func (*GetAttachmentUnauthorizedHeaders) currentUserRes() {} +func (*GetAttachmentUnauthorizedHeaders) downloadAttachmentRes() {} +func (*GetAttachmentUnauthorizedHeaders) getAttachmentRes() {} +func (*GetAttachmentUnauthorizedHeaders) getChatRes() {} +func (*GetAttachmentUnauthorizedHeaders) listChatsRes() {} +func (*GetAttachmentUnauthorizedHeaders) listMessagesRes() {} +func (*GetAttachmentUnauthorizedHeaders) revokeSessionRes() {} +func (*GetAttachmentUnauthorizedHeaders) uploadAttachmentRes() {} + type GetChatBadRequest ErrorHeaders func (*GetChatBadRequest) getChatRes() {} @@ -819,16 +1321,17 @@ func (*ListMessagesServiceUnavailable) listMessagesRes() {} // Ref: #/components/schemas/Message type Message struct { - ID uuid.UUID `json:"id"` - ChatID uuid.UUID `json:"chat_id"` - SenderID uuid.UUID `json:"sender_id"` - Text string `json:"text"` - CreatedAt time.Time `json:"created_at"` + AttachmentIds []uuid.UUID `json:"attachment_ids"` + ChatID uuid.UUID `json:"chat_id"` + CreatedAt time.Time `json:"created_at"` + ID uuid.UUID `json:"id"` + SenderID uuid.UUID `json:"sender_id"` + Text string `json:"text"` } -// GetID returns the value of ID. -func (s *Message) GetID() uuid.UUID { - return s.ID +// GetAttachmentIds returns the value of AttachmentIds. +func (s *Message) GetAttachmentIds() []uuid.UUID { + return s.AttachmentIds } // GetChatID returns the value of ChatID. @@ -836,6 +1339,16 @@ func (s *Message) GetChatID() uuid.UUID { return s.ChatID } +// GetCreatedAt returns the value of CreatedAt. +func (s *Message) GetCreatedAt() time.Time { + return s.CreatedAt +} + +// GetID returns the value of ID. +func (s *Message) GetID() uuid.UUID { + return s.ID +} + // GetSenderID returns the value of SenderID. func (s *Message) GetSenderID() uuid.UUID { return s.SenderID @@ -846,14 +1359,9 @@ func (s *Message) GetText() string { return s.Text } -// GetCreatedAt returns the value of CreatedAt. -func (s *Message) GetCreatedAt() time.Time { - return s.CreatedAt -} - -// SetID sets the value of ID. -func (s *Message) SetID(val uuid.UUID) { - s.ID = val +// SetAttachmentIds sets the value of AttachmentIds. +func (s *Message) SetAttachmentIds(val []uuid.UUID) { + s.AttachmentIds = val } // SetChatID sets the value of ChatID. @@ -861,6 +1369,16 @@ func (s *Message) SetChatID(val uuid.UUID) { s.ChatID = val } +// SetCreatedAt sets the value of CreatedAt. +func (s *Message) SetCreatedAt(val time.Time) { + s.CreatedAt = val +} + +// SetID sets the value of ID. +func (s *Message) SetID(val uuid.UUID) { + s.ID = val +} + // SetSenderID sets the value of SenderID. func (s *Message) SetSenderID(val uuid.UUID) { s.SenderID = val @@ -871,11 +1389,6 @@ func (s *Message) SetText(val string) { s.Text = val } -// SetCreatedAt sets the value of CreatedAt. -func (s *Message) SetCreatedAt(val time.Time) { - s.CreatedAt = val -} - // MessageHeaders wraps Message with response headers. type MessageHeaders struct { XInstanceID OptString @@ -1025,6 +1538,52 @@ func (o NilString) Or(d string) string { return d } +// NewOptDownloadAttachmentVariant returns new OptDownloadAttachmentVariant with value set to v. +func NewOptDownloadAttachmentVariant(v DownloadAttachmentVariant) OptDownloadAttachmentVariant { + return OptDownloadAttachmentVariant{ + Value: v, + Set: true, + } +} + +// OptDownloadAttachmentVariant is optional DownloadAttachmentVariant. +type OptDownloadAttachmentVariant struct { + Value DownloadAttachmentVariant + Set bool +} + +// IsSet returns true if OptDownloadAttachmentVariant was set. +func (o OptDownloadAttachmentVariant) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptDownloadAttachmentVariant) Reset() { + var v DownloadAttachmentVariant + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptDownloadAttachmentVariant) SetTo(v DownloadAttachmentVariant) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptDownloadAttachmentVariant) Get() (v DownloadAttachmentVariant, ok bool) { + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptDownloadAttachmentVariant) Or(d DownloadAttachmentVariant) DownloadAttachmentVariant { + if v, ok := o.Get(); ok { + return v + } + return d +} + // NewOptInt returns new OptInt with value set to v. func NewOptInt(v int) OptInt { return OptInt{ @@ -1179,12 +1738,17 @@ func (*RevokeSessionServiceUnavailable) revokeSessionRes() {} // Ref: #/components/schemas/Session type Session struct { + ExpiresAt time.Time `json:"expires_at"` Token string `json:"token"` TokenType string `json:"token_type"` - ExpiresAt time.Time `json:"expires_at"` User User `json:"user"` } +// GetExpiresAt returns the value of ExpiresAt. +func (s *Session) GetExpiresAt() time.Time { + return s.ExpiresAt +} + // GetToken returns the value of Token. func (s *Session) GetToken() string { return s.Token @@ -1195,16 +1759,16 @@ func (s *Session) GetTokenType() string { return s.TokenType } -// GetExpiresAt returns the value of ExpiresAt. -func (s *Session) GetExpiresAt() time.Time { - return s.ExpiresAt -} - // GetUser returns the value of User. func (s *Session) GetUser() User { return s.User } +// SetExpiresAt sets the value of ExpiresAt. +func (s *Session) SetExpiresAt(val time.Time) { + s.ExpiresAt = val +} + // SetToken sets the value of Token. func (s *Session) SetToken(val string) { s.Token = val @@ -1215,11 +1779,6 @@ func (s *Session) SetTokenType(val string) { s.TokenType = val } -// SetExpiresAt sets the value of ExpiresAt. -func (s *Session) SetExpiresAt(val time.Time) { - s.ExpiresAt = val -} - // SetUser sets the value of User. func (s *Session) SetUser(val User) { s.User = val @@ -1264,12 +1823,78 @@ func (s *SessionHeaders) SetResponse(val Session) { func (*SessionHeaders) createSessionRes() {} +type UploadAttachmentBadRequest ErrorHeaders + +func (*UploadAttachmentBadRequest) uploadAttachmentRes() {} + +type UploadAttachmentInternalServerError ErrorHeaders + +func (*UploadAttachmentInternalServerError) uploadAttachmentRes() {} + +type UploadAttachmentNotFound ErrorHeaders + +func (*UploadAttachmentNotFound) uploadAttachmentRes() {} + +type UploadAttachmentReqImageJpeg struct { + Data io.Reader +} + +// Read reads data from the Data reader. +// +// Kept to satisfy the io.Reader interface. +func (s UploadAttachmentReqImageJpeg) Read(p []byte) (n int, err error) { + if s.Data == nil { + return 0, io.EOF + } + return s.Data.Read(p) +} + +func (*UploadAttachmentReqImageJpeg) uploadAttachmentReq() {} + +type UploadAttachmentReqImagePNG struct { + Data io.Reader +} + +// Read reads data from the Data reader. +// +// Kept to satisfy the io.Reader interface. +func (s UploadAttachmentReqImagePNG) Read(p []byte) (n int, err error) { + if s.Data == nil { + return 0, io.EOF + } + return s.Data.Read(p) +} + +func (*UploadAttachmentReqImagePNG) uploadAttachmentReq() {} + +type UploadAttachmentRequestEntityTooLarge ErrorHeaders + +func (*UploadAttachmentRequestEntityTooLarge) uploadAttachmentRes() {} + +type UploadAttachmentServiceUnavailable ErrorHeaders + +func (*UploadAttachmentServiceUnavailable) uploadAttachmentRes() {} + +type UploadAttachmentUnsupportedMediaType ErrorHeaders + +func (*UploadAttachmentUnsupportedMediaType) uploadAttachmentRes() {} + // Ref: #/components/schemas/User type User struct { + CreatedAt time.Time `json:"created_at"` + DisplayName string `json:"display_name"` ID uuid.UUID `json:"id"` Username string `json:"username"` - DisplayName string `json:"display_name"` - CreatedAt time.Time `json:"created_at"` +} + +// GetCreatedAt returns the value of CreatedAt. +func (s *User) GetCreatedAt() time.Time { + return s.CreatedAt +} + +// GetDisplayName returns the value of DisplayName. +func (s *User) GetDisplayName() string { + return s.DisplayName } // GetID returns the value of ID. @@ -1282,14 +1907,14 @@ func (s *User) GetUsername() string { return s.Username } -// GetDisplayName returns the value of DisplayName. -func (s *User) GetDisplayName() string { - return s.DisplayName +// SetCreatedAt sets the value of CreatedAt. +func (s *User) SetCreatedAt(val time.Time) { + s.CreatedAt = val } -// GetCreatedAt returns the value of CreatedAt. -func (s *User) GetCreatedAt() time.Time { - return s.CreatedAt +// SetDisplayName sets the value of DisplayName. +func (s *User) SetDisplayName(val string) { + s.DisplayName = val } // SetID sets the value of ID. @@ -1302,16 +1927,6 @@ func (s *User) SetUsername(val string) { s.Username = val } -// SetDisplayName sets the value of DisplayName. -func (s *User) SetDisplayName(val string) { - s.DisplayName = val -} - -// SetCreatedAt sets the value of CreatedAt. -func (s *User) SetCreatedAt(val time.Time) { - s.CreatedAt = val -} - // UserHeaders wraps User with response headers. type UserHeaders struct { XInstanceID OptString @@ -1351,3 +1966,169 @@ func (s *UserHeaders) SetResponse(val User) { func (*UserHeaders) currentUserRes() {} func (*UserHeaders) registerUserRes() {} + +// Ref: #/components/schemas/Variant +type Variant struct { + ContentType VariantContentType `json:"content_type"` + Height int `json:"height"` + Name VariantName `json:"name"` + SHA256 string `json:"sha256"` + SizeBytes int `json:"size_bytes"` + Width int `json:"width"` +} + +// GetContentType returns the value of ContentType. +func (s *Variant) GetContentType() VariantContentType { + return s.ContentType +} + +// GetHeight returns the value of Height. +func (s *Variant) GetHeight() int { + return s.Height +} + +// GetName returns the value of Name. +func (s *Variant) GetName() VariantName { + return s.Name +} + +// GetSHA256 returns the value of SHA256. +func (s *Variant) GetSHA256() string { + return s.SHA256 +} + +// GetSizeBytes returns the value of SizeBytes. +func (s *Variant) GetSizeBytes() int { + return s.SizeBytes +} + +// GetWidth returns the value of Width. +func (s *Variant) GetWidth() int { + return s.Width +} + +// SetContentType sets the value of ContentType. +func (s *Variant) SetContentType(val VariantContentType) { + s.ContentType = val +} + +// SetHeight sets the value of Height. +func (s *Variant) SetHeight(val int) { + s.Height = val +} + +// SetName sets the value of Name. +func (s *Variant) SetName(val VariantName) { + s.Name = val +} + +// SetSHA256 sets the value of SHA256. +func (s *Variant) SetSHA256(val string) { + s.SHA256 = val +} + +// SetSizeBytes sets the value of SizeBytes. +func (s *Variant) SetSizeBytes(val int) { + s.SizeBytes = val +} + +// SetWidth sets the value of Width. +func (s *Variant) SetWidth(val int) { + s.Width = val +} + +type VariantContentType string + +const ( + VariantContentTypeImageJpeg VariantContentType = "image/jpeg" + VariantContentTypeImagePNG VariantContentType = "image/png" + VariantContentTypeImageWEBP VariantContentType = "image/webp" +) + +// AllValues returns all VariantContentType values. +func (VariantContentType) AllValues() []VariantContentType { + return []VariantContentType{ + VariantContentTypeImageJpeg, + VariantContentTypeImagePNG, + VariantContentTypeImageWEBP, + } +} + +// MarshalText implements encoding.TextMarshaler. +func (s VariantContentType) MarshalText() ([]byte, error) { + switch s { + case VariantContentTypeImageJpeg: + return []byte(s), nil + case VariantContentTypeImagePNG: + return []byte(s), nil + case VariantContentTypeImageWEBP: + return []byte(s), nil + default: + return nil, errors.Errorf("invalid value: %q", s) + } +} + +// UnmarshalText implements encoding.TextUnmarshaler. +func (s *VariantContentType) UnmarshalText(data []byte) error { + switch VariantContentType(data) { + case VariantContentTypeImageJpeg: + *s = VariantContentTypeImageJpeg + return nil + case VariantContentTypeImagePNG: + *s = VariantContentTypeImagePNG + return nil + case VariantContentTypeImageWEBP: + *s = VariantContentTypeImageWEBP + return nil + default: + return errors.Errorf("invalid value: %q", data) + } +} + +type VariantName string + +const ( + VariantNameThumbnail VariantName = "thumbnail" + VariantNameCrop VariantName = "crop" + VariantNameOptimized VariantName = "optimized" +) + +// AllValues returns all VariantName values. +func (VariantName) AllValues() []VariantName { + return []VariantName{ + VariantNameThumbnail, + VariantNameCrop, + VariantNameOptimized, + } +} + +// MarshalText implements encoding.TextMarshaler. +func (s VariantName) MarshalText() ([]byte, error) { + switch s { + case VariantNameThumbnail: + return []byte(s), nil + case VariantNameCrop: + return []byte(s), nil + case VariantNameOptimized: + return []byte(s), nil + default: + return nil, errors.Errorf("invalid value: %q", s) + } +} + +// UnmarshalText implements encoding.TextUnmarshaler. +func (s *VariantName) UnmarshalText(data []byte) error { + switch VariantName(data) { + case VariantNameThumbnail: + *s = VariantNameThumbnail + return nil + case VariantNameCrop: + *s = VariantNameCrop + return nil + case VariantNameOptimized: + *s = VariantNameOptimized + return nil + default: + return errors.Errorf("invalid value: %q", data) + } +} diff --git a/internal/transport/rest/internal/oas/oas_security_gen.go b/internal/transport/rest/internal/oas/oas_security_gen.go index 60303072..41d4c5cd 100644 --- a/internal/transport/rest/internal/oas/oas_security_gen.go +++ b/internal/transport/rest/internal/oas/oas_security_gen.go @@ -62,13 +62,16 @@ func GetRolesForBasicAuth(operation string) []string { // operationRolesBearerAuth is a private map storing roles per operation. var operationRolesBearerAuth = map[string][]string{ - CreateChatOperation: []string{}, - CreateMessageOperation: []string{}, - CurrentUserOperation: []string{}, - GetChatOperation: []string{}, - ListChatsOperation: []string{}, - ListMessagesOperation: []string{}, - RevokeSessionOperation: []string{}, + CreateChatOperation: []string{}, + CreateMessageOperation: []string{}, + CurrentUserOperation: []string{}, + DownloadAttachmentOperation: []string{}, + GetAttachmentOperation: []string{}, + GetChatOperation: []string{}, + ListChatsOperation: []string{}, + ListMessagesOperation: []string{}, + RevokeSessionOperation: []string{}, + UploadAttachmentOperation: []string{}, } // GetRolesForBearerAuth returns the required roles for the given operation. diff --git a/internal/transport/rest/internal/oas/oas_server_gen.go b/internal/transport/rest/internal/oas/oas_server_gen.go index 93463c13..62a1b1d9 100644 --- a/internal/transport/rest/internal/oas/oas_server_gen.go +++ b/internal/transport/rest/internal/oas/oas_server_gen.go @@ -32,6 +32,18 @@ type Handler interface { // // GET /api/v1/users/me CurrentUser(ctx context.Context) (CurrentUserRes, error) + // DownloadAttachment implements downloadAttachment operation. + // + // Скачать байты через авторизованный API. + // + // GET /api/v1/attachments/{attachment_id}/content + DownloadAttachment(ctx context.Context, params DownloadAttachmentParams) (DownloadAttachmentRes, error) + // GetAttachment implements getAttachment operation. + // + // Метаданные вложения, доступ участникам чата. + // + // GET /api/v1/attachments/{attachment_id} + GetAttachment(ctx context.Context, params GetAttachmentParams) (GetAttachmentRes, error) // GetChat implements getChat operation. // // Получить доступный чат. @@ -74,6 +86,12 @@ type Handler interface { // // DELETE /api/v1/auth/sessions/current RevokeSession(ctx context.Context) (RevokeSessionRes, error) + // UploadAttachment implements uploadAttachment operation. + // + // Принять один PNG/JPEG, до 10 MiB. + // + // POST /api/v1/chats/{chat_id}/attachments + UploadAttachment(ctx context.Context, req UploadAttachmentReq, params UploadAttachmentParams) (UploadAttachmentRes, error) } // Server implements http server based on OpenAPI v3 specification and diff --git a/internal/transport/rest/internal/oas/oas_unimplemented_gen.go b/internal/transport/rest/internal/oas/oas_unimplemented_gen.go index 7d2dc7e1..37cd2143 100644 --- a/internal/transport/rest/internal/oas/oas_unimplemented_gen.go +++ b/internal/transport/rest/internal/oas/oas_unimplemented_gen.go @@ -49,6 +49,24 @@ func (UnimplementedHandler) CurrentUser(ctx context.Context) (r CurrentUserRes, return r, ht.ErrNotImplemented } +// DownloadAttachment implements downloadAttachment operation. +// +// Скачать байты через авторизованный API. +// +// GET /api/v1/attachments/{attachment_id}/content +func (UnimplementedHandler) DownloadAttachment(ctx context.Context, params DownloadAttachmentParams) (r DownloadAttachmentRes, _ error) { + return r, ht.ErrNotImplemented +} + +// GetAttachment implements getAttachment operation. +// +// Метаданные вложения, доступ участникам чата. +// +// GET /api/v1/attachments/{attachment_id} +func (UnimplementedHandler) GetAttachment(ctx context.Context, params GetAttachmentParams) (r GetAttachmentRes, _ error) { + return r, ht.ErrNotImplemented +} + // GetChat implements getChat operation. // // Получить доступный чат. @@ -111,3 +129,12 @@ func (UnimplementedHandler) RegisterUser(ctx context.Context, req *CreateUser) ( func (UnimplementedHandler) RevokeSession(ctx context.Context) (r RevokeSessionRes, _ error) { return r, ht.ErrNotImplemented } + +// UploadAttachment implements uploadAttachment operation. +// +// Принять один PNG/JPEG, до 10 MiB. +// +// POST /api/v1/chats/{chat_id}/attachments +func (UnimplementedHandler) UploadAttachment(ctx context.Context, req UploadAttachmentReq, params UploadAttachmentParams) (r UploadAttachmentRes, _ error) { + return r, ht.ErrNotImplemented +} diff --git a/internal/transport/rest/internal/oas/oas_validators_gen.go b/internal/transport/rest/internal/oas/oas_validators_gen.go index bad56ad4..8c2402ed 100644 --- a/internal/transport/rest/internal/oas/oas_validators_gen.go +++ b/internal/transport/rest/internal/oas/oas_validators_gen.go @@ -9,12 +9,266 @@ import ( "github.com/ogen-go/ogen/validate" ) +func (s *Attachment) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if err := s.ContentType.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "content_type", + Error: err, + }) + } + if err := func() error { + if err := (validate.String{ + MinLength: 1, + MinLengthSet: true, + MaxLength: 255, + MaxLengthSet: true, + Email: false, + Hostname: false, + Regex: nil, + MinNumeric: 0, + MinNumericSet: false, + MaxNumeric: 0, + MaxNumericSet: false, + }).Validate(string(s.Filename)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "filename", + Error: err, + }) + } + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: false, + Hostname: false, + Regex: regexMap["^[a-f0-9]{64}$"], + MinNumeric: 0, + MinNumericSet: false, + MaxNumeric: 0, + MaxNumericSet: false, + }).Validate(string(s.SHA256)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "sha256", + Error: err, + }) + } + if err := func() error { + if err := (validate.Int{ + MinSet: true, + Min: 1, + MaxSet: true, + Max: 10485760, + MinExclusive: false, + MaxExclusive: false, + MultipleOfSet: false, + MultipleOf: 0, + Pattern: nil, + }).Validate(int64(s.SizeBytes)); err != nil { + return errors.Wrap(err, "int") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "size_bytes", + Error: err, + }) + } + if err := func() error { + if err := s.Status.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "status", + Error: err, + }) + } + if err := func() error { + if s.Variants == nil { + return errors.New("nil is invalid value") + } + var failures []validate.FieldError + for i, elem := range s.Variants { + if err := func() error { + if err := elem.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "variants", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s AttachmentContentType) Validate() error { + switch s { + case "image/png": + return nil + case "image/jpeg": + return nil + default: + return errors.Errorf("invalid value: %v", s) + } +} + +func (s *AttachmentHeaders) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if value, ok := s.XInstanceID.Get(); ok { + if err := func() error { + if err := (validate.String{ + MinLength: 1, + MinLengthSet: true, + MaxLength: 0, + MaxLengthSet: false, + Email: false, + Hostname: false, + Regex: nil, + MinNumeric: 0, + MinNumericSet: false, + MaxNumeric: 0, + MaxNumericSet: false, + }).Validate(string(value)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "XInstanceID", + Error: err, + }) + } + if err := func() error { + if value, ok := s.XRequestID.Get(); ok { + if err := func() error { + if err := (validate.String{ + MinLength: 1, + MinLengthSet: true, + MaxLength: 0, + MaxLengthSet: false, + Email: false, + Hostname: false, + Regex: nil, + MinNumeric: 0, + MinNumericSet: false, + MaxNumeric: 0, + MaxNumericSet: false, + }).Validate(string(value)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "XRequestID", + Error: err, + }) + } + if err := func() error { + if err := s.Response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "Response", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s AttachmentStatus) Validate() error { + switch s { + case "ready": + return nil + default: + return errors.Errorf("invalid value: %v", s) + } +} + func (s *Chat) Validate() error { if s == nil { return validate.ErrNilPointer } var failures []validate.FieldError + if err := func() error { + if s.MemberIds == nil { + return errors.New("nil is invalid value") + } + if err := (validate.Array{ + MinLength: 1, + MinLengthSet: true, + MaxLength: 100, + MaxLengthSet: true, + }).ValidateLength(len(s.MemberIds)); err != nil { + return errors.Wrap(err, "array") + } + if err := validate.UniqueItems(s.MemberIds); err != nil { + return errors.Wrap(err, "array") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "member_ids", + Error: err, + }) + } if err := func() error { if err := (validate.String{ MinLength: 1, @@ -38,28 +292,6 @@ func (s *Chat) Validate() error { Error: err, }) } - if err := func() error { - if s.MemberIds == nil { - return errors.New("nil is invalid value") - } - if err := (validate.Array{ - MinLength: 1, - MinLengthSet: true, - MaxLength: 100, - MaxLengthSet: true, - }).ValidateLength(len(s.MemberIds)); err != nil { - return errors.Wrap(err, "array") - } - if err := validate.UniqueItems(s.MemberIds); err != nil { - return errors.Wrap(err, "array") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: "member_ids", - Error: err, - }) - } if len(failures) > 0 { return &validate.Error{Fields: failures} } @@ -278,6 +510,28 @@ func (s *CreateChat) Validate() error { } var failures []validate.FieldError + if err := func() error { + if s.MemberIds == nil { + return errors.New("nil is invalid value") + } + if err := (validate.Array{ + MinLength: 1, + MinLengthSet: true, + MaxLength: 100, + MaxLengthSet: true, + }).ValidateLength(len(s.MemberIds)); err != nil { + return errors.Wrap(err, "array") + } + if err := validate.UniqueItems(s.MemberIds); err != nil { + return errors.Wrap(err, "array") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "member_ids", + Error: err, + }) + } if err := func() error { if err := (validate.String{ MinLength: 1, @@ -301,28 +555,6 @@ func (s *CreateChat) Validate() error { Error: err, }) } - if err := func() error { - if s.MemberIds == nil { - return errors.New("nil is invalid value") - } - if err := (validate.Array{ - MinLength: 1, - MinLengthSet: true, - MaxLength: 100, - MaxLengthSet: true, - }).ValidateLength(len(s.MemberIds)); err != nil { - return errors.Wrap(err, "array") - } - if err := validate.UniqueItems(s.MemberIds); err != nil { - return errors.Wrap(err, "array") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: "member_ids", - Error: err, - }) - } if len(failures) > 0 { return &validate.Error{Fields: failures} } @@ -375,10 +607,32 @@ func (s *CreateMessage) Validate() error { } var failures []validate.FieldError + if err := func() error { + if s.AttachmentIds == nil { + return nil // optional + } + if err := (validate.Array{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 10, + MaxLengthSet: true, + }).ValidateLength(len(s.AttachmentIds)); err != nil { + return errors.Wrap(err, "array") + } + if err := validate.UniqueItems(s.AttachmentIds); err != nil { + return errors.Wrap(err, "array") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "attachment_ids", + Error: err, + }) + } if err := func() error { if err := (validate.String{ - MinLength: 1, - MinLengthSet: true, + MinLength: 0, + MinLengthSet: false, MaxLength: 4000, MaxLengthSet: true, Email: false, @@ -468,229 +722,12 @@ func (s *CreateSessionServiceUnavailable) Validate() error { return nil } -func (s *CreateSessionTooManyRequestsHeaders) Validate() error { - if s == nil { - return validate.ErrNilPointer - } - - var failures []validate.FieldError - if err := func() error { - if value, ok := s.RetryAfter.Get(); ok { - if err := func() error { - if err := (validate.Int{ - MinSet: true, - Min: 1, - MaxSet: false, - Max: 0, - MinExclusive: false, - MaxExclusive: false, - MultipleOfSet: false, - MultipleOf: 0, - Pattern: nil, - }).Validate(int64(value)); err != nil { - return errors.Wrap(err, "int") - } - return nil - }(); err != nil { - return err - } - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: "RetryAfter", - Error: err, - }) - } - if err := func() error { - if value, ok := s.XInstanceID.Get(); ok { - if err := func() error { - if err := (validate.String{ - MinLength: 1, - MinLengthSet: true, - MaxLength: 0, - MaxLengthSet: false, - Email: false, - Hostname: false, - Regex: nil, - MinNumeric: 0, - MinNumericSet: false, - MaxNumeric: 0, - MaxNumericSet: false, - }).Validate(string(value)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - return err - } - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: "XInstanceID", - Error: err, - }) - } - if err := func() error { - if value, ok := s.XRequestID.Get(); ok { - if err := func() error { - if err := (validate.String{ - MinLength: 1, - MinLengthSet: true, - MaxLength: 0, - MaxLengthSet: false, - Email: false, - Hostname: false, - Regex: nil, - MinNumeric: 0, - MinNumericSet: false, - MaxNumeric: 0, - MaxNumericSet: false, - }).Validate(string(value)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - return err - } - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: "XRequestID", - Error: err, - }) - } - if err := func() error { - if err := s.Response.Validate(); err != nil { - return err - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: "Response", - Error: err, - }) - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } - return nil -} - -func (s *CreateSessionUnauthorizedHeaders) Validate() error { - if s == nil { - return validate.ErrNilPointer - } - - var failures []validate.FieldError - if err := func() error { - if value, ok := s.XInstanceID.Get(); ok { - if err := func() error { - if err := (validate.String{ - MinLength: 1, - MinLengthSet: true, - MaxLength: 0, - MaxLengthSet: false, - Email: false, - Hostname: false, - Regex: nil, - MinNumeric: 0, - MinNumericSet: false, - MaxNumeric: 0, - MaxNumericSet: false, - }).Validate(string(value)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - return err - } - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: "XInstanceID", - Error: err, - }) - } - if err := func() error { - if value, ok := s.XRequestID.Get(); ok { - if err := func() error { - if err := (validate.String{ - MinLength: 1, - MinLengthSet: true, - MaxLength: 0, - MaxLengthSet: false, - Email: false, - Hostname: false, - Regex: nil, - MinNumeric: 0, - MinNumericSet: false, - MaxNumeric: 0, - MaxNumericSet: false, - }).Validate(string(value)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - return err - } - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: "XRequestID", - Error: err, - }) - } - if err := func() error { - if err := s.Response.Validate(); err != nil { - return err - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: "Response", - Error: err, - }) - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } - return nil -} - func (s *CreateUser) Validate() error { if s == nil { return validate.ErrNilPointer } var failures []validate.FieldError - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: false, - Hostname: false, - Regex: regexMap["^[a-z0-9_]{3,32}$"], - MinNumeric: 0, - MinNumericSet: false, - MaxNumeric: 0, - MaxNumericSet: false, - }).Validate(string(s.Username)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: "username", - Error: err, - }) - } if err := func() error { if err := (validate.String{ MinLength: 1, @@ -737,6 +774,29 @@ func (s *CreateUser) Validate() error { Error: err, }) } + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: false, + Hostname: false, + Regex: regexMap["^[a-z0-9_]{3,32}$"], + MinNumeric: 0, + MinNumericSet: false, + MaxNumeric: 0, + MaxNumericSet: false, + }).Validate(string(s.Username)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "username", + Error: err, + }) + } if len(failures) > 0 { return &validate.Error{Fields: failures} } @@ -783,6 +843,271 @@ func (s *CurrentUserServiceUnavailable) Validate() error { return nil } +func (s *DownloadAttachmentBadRequest) Validate() error { + alias := (*ErrorHeaders)(s) + if err := alias.Validate(); err != nil { + return err + } + return nil +} + +func (s *DownloadAttachmentConflict) Validate() error { + alias := (*ErrorHeaders)(s) + if err := alias.Validate(); err != nil { + return err + } + return nil +} + +func (s *DownloadAttachmentInternalServerError) Validate() error { + alias := (*ErrorHeaders)(s) + if err := alias.Validate(); err != nil { + return err + } + return nil +} + +func (s *DownloadAttachmentNotFound) Validate() error { + alias := (*ErrorHeaders)(s) + if err := alias.Validate(); err != nil { + return err + } + return nil +} + +func (s *DownloadAttachmentOKImageJpegHeaders) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if value, ok := s.XInstanceID.Get(); ok { + if err := func() error { + if err := (validate.String{ + MinLength: 1, + MinLengthSet: true, + MaxLength: 0, + MaxLengthSet: false, + Email: false, + Hostname: false, + Regex: nil, + MinNumeric: 0, + MinNumericSet: false, + MaxNumeric: 0, + MaxNumericSet: false, + }).Validate(string(value)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "XInstanceID", + Error: err, + }) + } + if err := func() error { + if value, ok := s.XRequestID.Get(); ok { + if err := func() error { + if err := (validate.String{ + MinLength: 1, + MinLengthSet: true, + MaxLength: 0, + MaxLengthSet: false, + Email: false, + Hostname: false, + Regex: nil, + MinNumeric: 0, + MinNumericSet: false, + MaxNumeric: 0, + MaxNumericSet: false, + }).Validate(string(value)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "XRequestID", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *DownloadAttachmentOKImagePNGHeaders) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if value, ok := s.XInstanceID.Get(); ok { + if err := func() error { + if err := (validate.String{ + MinLength: 1, + MinLengthSet: true, + MaxLength: 0, + MaxLengthSet: false, + Email: false, + Hostname: false, + Regex: nil, + MinNumeric: 0, + MinNumericSet: false, + MaxNumeric: 0, + MaxNumericSet: false, + }).Validate(string(value)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "XInstanceID", + Error: err, + }) + } + if err := func() error { + if value, ok := s.XRequestID.Get(); ok { + if err := func() error { + if err := (validate.String{ + MinLength: 1, + MinLengthSet: true, + MaxLength: 0, + MaxLengthSet: false, + Email: false, + Hostname: false, + Regex: nil, + MinNumeric: 0, + MinNumericSet: false, + MaxNumeric: 0, + MaxNumericSet: false, + }).Validate(string(value)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "XRequestID", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *DownloadAttachmentOKImageWEBPHeaders) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if value, ok := s.XInstanceID.Get(); ok { + if err := func() error { + if err := (validate.String{ + MinLength: 1, + MinLengthSet: true, + MaxLength: 0, + MaxLengthSet: false, + Email: false, + Hostname: false, + Regex: nil, + MinNumeric: 0, + MinNumericSet: false, + MaxNumeric: 0, + MaxNumericSet: false, + }).Validate(string(value)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "XInstanceID", + Error: err, + }) + } + if err := func() error { + if value, ok := s.XRequestID.Get(); ok { + if err := func() error { + if err := (validate.String{ + MinLength: 1, + MinLengthSet: true, + MaxLength: 0, + MaxLengthSet: false, + Email: false, + Hostname: false, + Regex: nil, + MinNumeric: 0, + MinNumericSet: false, + MaxNumeric: 0, + MaxNumericSet: false, + }).Validate(string(value)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "XRequestID", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *DownloadAttachmentServiceUnavailable) Validate() error { + alias := (*ErrorHeaders)(s) + if err := alias.Validate(); err != nil { + return err + } + return nil +} + +func (s DownloadAttachmentVariant) Validate() error { + switch s { + case "original": + return nil + default: + return errors.Errorf("invalid value: %v", s) + } +} + func (s *Error) Validate() error { if s == nil { return validate.ErrNilPointer @@ -983,6 +1308,240 @@ func (s *ErrorHeaders) Validate() error { return nil } +func (s *GetAttachmentBadRequest) Validate() error { + alias := (*ErrorHeaders)(s) + if err := alias.Validate(); err != nil { + return err + } + return nil +} + +func (s *GetAttachmentConflict) Validate() error { + alias := (*ErrorHeaders)(s) + if err := alias.Validate(); err != nil { + return err + } + return nil +} + +func (s *GetAttachmentInternalServerError) Validate() error { + alias := (*ErrorHeaders)(s) + if err := alias.Validate(); err != nil { + return err + } + return nil +} + +func (s *GetAttachmentNotFound) Validate() error { + alias := (*ErrorHeaders)(s) + if err := alias.Validate(); err != nil { + return err + } + return nil +} + +func (s *GetAttachmentServiceUnavailable) Validate() error { + alias := (*ErrorHeaders)(s) + if err := alias.Validate(); err != nil { + return err + } + return nil +} + +func (s *GetAttachmentTooManyRequestsHeaders) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if value, ok := s.RetryAfter.Get(); ok { + if err := func() error { + if err := (validate.Int{ + MinSet: true, + Min: 1, + MaxSet: false, + Max: 0, + MinExclusive: false, + MaxExclusive: false, + MultipleOfSet: false, + MultipleOf: 0, + Pattern: nil, + }).Validate(int64(value)); err != nil { + return errors.Wrap(err, "int") + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "RetryAfter", + Error: err, + }) + } + if err := func() error { + if value, ok := s.XInstanceID.Get(); ok { + if err := func() error { + if err := (validate.String{ + MinLength: 1, + MinLengthSet: true, + MaxLength: 0, + MaxLengthSet: false, + Email: false, + Hostname: false, + Regex: nil, + MinNumeric: 0, + MinNumericSet: false, + MaxNumeric: 0, + MaxNumericSet: false, + }).Validate(string(value)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "XInstanceID", + Error: err, + }) + } + if err := func() error { + if value, ok := s.XRequestID.Get(); ok { + if err := func() error { + if err := (validate.String{ + MinLength: 1, + MinLengthSet: true, + MaxLength: 0, + MaxLengthSet: false, + Email: false, + Hostname: false, + Regex: nil, + MinNumeric: 0, + MinNumericSet: false, + MaxNumeric: 0, + MaxNumericSet: false, + }).Validate(string(value)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "XRequestID", + Error: err, + }) + } + if err := func() error { + if err := s.Response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "Response", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *GetAttachmentUnauthorizedHeaders) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if value, ok := s.XInstanceID.Get(); ok { + if err := func() error { + if err := (validate.String{ + MinLength: 1, + MinLengthSet: true, + MaxLength: 0, + MaxLengthSet: false, + Email: false, + Hostname: false, + Regex: nil, + MinNumeric: 0, + MinNumericSet: false, + MaxNumeric: 0, + MaxNumericSet: false, + }).Validate(string(value)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "XInstanceID", + Error: err, + }) + } + if err := func() error { + if value, ok := s.XRequestID.Get(); ok { + if err := func() error { + if err := (validate.String{ + MinLength: 1, + MinLengthSet: true, + MaxLength: 0, + MaxLengthSet: false, + Email: false, + Hostname: false, + Regex: nil, + MinNumeric: 0, + MinNumericSet: false, + MaxNumeric: 0, + MaxNumericSet: false, + }).Validate(string(value)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "XRequestID", + Error: err, + }) + } + if err := func() error { + if err := s.Response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "Response", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + func (s *GetChatBadRequest) Validate() error { alias := (*ErrorHeaders)(s) if err := alias.Validate(); err != nil { @@ -1224,10 +1783,32 @@ func (s *Message) Validate() error { } var failures []validate.FieldError + if err := func() error { + if s.AttachmentIds == nil { + return errors.New("nil is invalid value") + } + if err := (validate.Array{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 10, + MaxLengthSet: true, + }).ValidateLength(len(s.AttachmentIds)); err != nil { + return errors.Wrap(err, "array") + } + if err := validate.UniqueItems(s.AttachmentIds); err != nil { + return errors.Wrap(err, "array") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "attachment_ids", + Error: err, + }) + } if err := func() error { if err := (validate.String{ - MinLength: 1, - MinLengthSet: true, + MinLength: 0, + MinLengthSet: false, MaxLength: 4000, MaxLengthSet: true, Email: false, @@ -1724,35 +2305,60 @@ func (s *SessionHeaders) Validate() error { return nil } +func (s *UploadAttachmentBadRequest) Validate() error { + alias := (*ErrorHeaders)(s) + if err := alias.Validate(); err != nil { + return err + } + return nil +} + +func (s *UploadAttachmentInternalServerError) Validate() error { + alias := (*ErrorHeaders)(s) + if err := alias.Validate(); err != nil { + return err + } + return nil +} + +func (s *UploadAttachmentNotFound) Validate() error { + alias := (*ErrorHeaders)(s) + if err := alias.Validate(); err != nil { + return err + } + return nil +} + +func (s *UploadAttachmentRequestEntityTooLarge) Validate() error { + alias := (*ErrorHeaders)(s) + if err := alias.Validate(); err != nil { + return err + } + return nil +} + +func (s *UploadAttachmentServiceUnavailable) Validate() error { + alias := (*ErrorHeaders)(s) + if err := alias.Validate(); err != nil { + return err + } + return nil +} + +func (s *UploadAttachmentUnsupportedMediaType) Validate() error { + alias := (*ErrorHeaders)(s) + if err := alias.Validate(); err != nil { + return err + } + return nil +} + func (s *User) Validate() error { if s == nil { return validate.ErrNilPointer } var failures []validate.FieldError - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: false, - Hostname: false, - Regex: regexMap["^[a-z0-9_]{3,32}$"], - MinNumeric: 0, - MinNumericSet: false, - MaxNumeric: 0, - MaxNumericSet: false, - }).Validate(string(s.Username)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: "username", - Error: err, - }) - } if err := func() error { if err := (validate.String{ MinLength: 1, @@ -1776,6 +2382,29 @@ func (s *User) Validate() error { Error: err, }) } + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: false, + Hostname: false, + Regex: regexMap["^[a-z0-9_]{3,32}$"], + MinNumeric: 0, + MinNumericSet: false, + MaxNumeric: 0, + MaxNumericSet: false, + }).Validate(string(s.Username)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "username", + Error: err, + }) + } if len(failures) > 0 { return &validate.Error{Fields: failures} } @@ -1864,3 +2493,149 @@ func (s *UserHeaders) Validate() error { } return nil } + +func (s *Variant) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if err := s.ContentType.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "content_type", + Error: err, + }) + } + if err := func() error { + if err := (validate.Int{ + MinSet: true, + Min: 1, + MaxSet: false, + Max: 0, + MinExclusive: false, + MaxExclusive: false, + MultipleOfSet: false, + MultipleOf: 0, + Pattern: nil, + }).Validate(int64(s.Height)); err != nil { + return errors.Wrap(err, "int") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "height", + Error: err, + }) + } + if err := func() error { + if err := s.Name.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "name", + Error: err, + }) + } + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: false, + Hostname: false, + Regex: regexMap["^[a-f0-9]{64}$"], + MinNumeric: 0, + MinNumericSet: false, + MaxNumeric: 0, + MaxNumericSet: false, + }).Validate(string(s.SHA256)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "sha256", + Error: err, + }) + } + if err := func() error { + if err := (validate.Int{ + MinSet: true, + Min: 1, + MaxSet: false, + Max: 0, + MinExclusive: false, + MaxExclusive: false, + MultipleOfSet: false, + MultipleOf: 0, + Pattern: nil, + }).Validate(int64(s.SizeBytes)); err != nil { + return errors.Wrap(err, "int") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "size_bytes", + Error: err, + }) + } + if err := func() error { + if err := (validate.Int{ + MinSet: true, + Min: 1, + MaxSet: false, + Max: 0, + MinExclusive: false, + MaxExclusive: false, + MultipleOfSet: false, + MultipleOf: 0, + Pattern: nil, + }).Validate(int64(s.Width)); err != nil { + return errors.Wrap(err, "int") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "width", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s VariantContentType) Validate() error { + switch s { + case "image/jpeg": + return nil + case "image/png": + return nil + case "image/webp": + return nil + default: + return errors.Errorf("invalid value: %v", s) + } +} + +func (s VariantName) Validate() error { + switch s { + case "thumbnail": + return nil + case "crop": + return nil + case "optimized": + return nil + default: + return errors.Errorf("invalid value: %v", s) + } +} diff --git a/internal/transport/rest/mocks/AttachmentService.go b/internal/transport/rest/mocks/AttachmentService.go new file mode 100644 index 00000000..9177c331 --- /dev/null +++ b/internal/transport/rest/mocks/AttachmentService.go @@ -0,0 +1,413 @@ +// Code generated by mockery; DO NOT EDIT. +// github.com/vektra/mockery +// template: testify + +package mocks + +import ( + "context" + "io" + "mtusi-messenger/internal/domain" + "mtusi-messenger/internal/service/attachment" + + "github.com/google/uuid" + mock "github.com/stretchr/testify/mock" +) + +// NewMockAttachmentService creates a new instance of MockAttachmentService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockAttachmentService(t interface { + mock.TestingT + Cleanup(func()) +}) *MockAttachmentService { + if helper, ok := t.(interface{ Helper() }); ok { + helper.Helper() + } + + mock := &MockAttachmentService{} + mock.Mock.Test(t) + + t.Cleanup(func() { + if helper, ok := t.(interface{ Helper() }); ok { + helper.Helper() + } + mock.AssertExpectations(t) + }) + + return mock +} + +// MockAttachmentService is an autogenerated mock type for the AttachmentService type +type MockAttachmentService struct { + mock.Mock +} + +type MockAttachmentService_Expecter struct { + mock *mock.Mock +} + +func (_m *MockAttachmentService) EXPECT() *MockAttachmentService_Expecter { + return &MockAttachmentService_Expecter{mock: &_m.Mock} +} + +// Complete provides a mock function for the type MockAttachmentService +func (_mock *MockAttachmentService) Complete(ctx context.Context, ownerID uuid.UUID, id uuid.UUID, sha256 string) (domain.Attachment, error) { + ret := _mock.Called(ctx, ownerID, id, sha256) + + if len(ret) == 0 { + panic("no return value specified for Complete") + } + + var r0 domain.Attachment + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, uuid.UUID, uuid.UUID, string) (domain.Attachment, error)); ok { + return returnFunc(ctx, ownerID, id, sha256) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, uuid.UUID, uuid.UUID, string) domain.Attachment); ok { + r0 = returnFunc(ctx, ownerID, id, sha256) + } else { + r0 = ret.Get(0).(domain.Attachment) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, uuid.UUID, uuid.UUID, string) error); ok { + r1 = returnFunc(ctx, ownerID, id, sha256) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAttachmentService_Complete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Complete' +type MockAttachmentService_Complete_Call struct { + *mock.Call +} + +// Complete is a helper method to define mock.On call +// - ctx context.Context +// - ownerID uuid.UUID +// - id uuid.UUID +// - sha256 string +func (_e *MockAttachmentService_Expecter) Complete(ctx any, ownerID any, id any, sha256 any) *MockAttachmentService_Complete_Call { + return &MockAttachmentService_Complete_Call{Call: _e.mock.On("Complete", ctx, ownerID, id, sha256)} +} + +func (_c *MockAttachmentService_Complete_Call) Run(run func(ctx context.Context, ownerID uuid.UUID, id uuid.UUID, sha256 string)) *MockAttachmentService_Complete_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 uuid.UUID + if args[1] != nil { + arg1 = args[1].(uuid.UUID) + } + var arg2 uuid.UUID + if args[2] != nil { + arg2 = args[2].(uuid.UUID) + } + var arg3 string + if args[3] != nil { + arg3 = args[3].(string) + } + run( + arg0, + arg1, + arg2, + arg3, + ) + }) + return _c +} + +func (_c *MockAttachmentService_Complete_Call) Return(attachment domain.Attachment, err error) *MockAttachmentService_Complete_Call { + _c.Call.Return(attachment, err) + return _c +} + +func (_c *MockAttachmentService_Complete_Call) RunAndReturn(run func(ctx context.Context, ownerID uuid.UUID, id uuid.UUID, sha256 string) (domain.Attachment, error)) *MockAttachmentService_Complete_Call { + _c.Call.Return(run) + return _c +} + +// Get provides a mock function for the type MockAttachmentService +func (_mock *MockAttachmentService) Get(ctx context.Context, callerID uuid.UUID, id uuid.UUID) (domain.Attachment, error) { + ret := _mock.Called(ctx, callerID, id) + + if len(ret) == 0 { + panic("no return value specified for Get") + } + + var r0 domain.Attachment + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, uuid.UUID, uuid.UUID) (domain.Attachment, error)); ok { + return returnFunc(ctx, callerID, id) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, uuid.UUID, uuid.UUID) domain.Attachment); ok { + r0 = returnFunc(ctx, callerID, id) + } else { + r0 = ret.Get(0).(domain.Attachment) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, uuid.UUID, uuid.UUID) error); ok { + r1 = returnFunc(ctx, callerID, id) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAttachmentService_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type MockAttachmentService_Get_Call struct { + *mock.Call +} + +// Get is a helper method to define mock.On call +// - ctx context.Context +// - callerID uuid.UUID +// - id uuid.UUID +func (_e *MockAttachmentService_Expecter) Get(ctx any, callerID any, id any) *MockAttachmentService_Get_Call { + return &MockAttachmentService_Get_Call{Call: _e.mock.On("Get", ctx, callerID, id)} +} + +func (_c *MockAttachmentService_Get_Call) Run(run func(ctx context.Context, callerID uuid.UUID, id uuid.UUID)) *MockAttachmentService_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 uuid.UUID + if args[1] != nil { + arg1 = args[1].(uuid.UUID) + } + var arg2 uuid.UUID + if args[2] != nil { + arg2 = args[2].(uuid.UUID) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *MockAttachmentService_Get_Call) Return(attachment domain.Attachment, err error) *MockAttachmentService_Get_Call { + _c.Call.Return(attachment, err) + return _c +} + +func (_c *MockAttachmentService_Get_Call) RunAndReturn(run func(ctx context.Context, callerID uuid.UUID, id uuid.UUID) (domain.Attachment, error)) *MockAttachmentService_Get_Call { + _c.Call.Return(run) + return _c +} + +// Open provides a mock function for the type MockAttachmentService +func (_mock *MockAttachmentService) Open(ctx context.Context, callerID uuid.UUID, id uuid.UUID) (domain.Attachment, io.ReadCloser, error) { + ret := _mock.Called(ctx, callerID, id) + + if len(ret) == 0 { + panic("no return value specified for Open") + } + + var r0 domain.Attachment + var r1 io.ReadCloser + var r2 error + if returnFunc, ok := ret.Get(0).(func(context.Context, uuid.UUID, uuid.UUID) (domain.Attachment, io.ReadCloser, error)); ok { + return returnFunc(ctx, callerID, id) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, uuid.UUID, uuid.UUID) domain.Attachment); ok { + r0 = returnFunc(ctx, callerID, id) + } else { + r0 = ret.Get(0).(domain.Attachment) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, uuid.UUID, uuid.UUID) io.ReadCloser); ok { + r1 = returnFunc(ctx, callerID, id) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(io.ReadCloser) + } + } + if returnFunc, ok := ret.Get(2).(func(context.Context, uuid.UUID, uuid.UUID) error); ok { + r2 = returnFunc(ctx, callerID, id) + } else { + r2 = ret.Error(2) + } + return r0, r1, r2 +} + +// MockAttachmentService_Open_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Open' +type MockAttachmentService_Open_Call struct { + *mock.Call +} + +// Open is a helper method to define mock.On call +// - ctx context.Context +// - callerID uuid.UUID +// - id uuid.UUID +func (_e *MockAttachmentService_Expecter) Open(ctx any, callerID any, id any) *MockAttachmentService_Open_Call { + return &MockAttachmentService_Open_Call{Call: _e.mock.On("Open", ctx, callerID, id)} +} + +func (_c *MockAttachmentService_Open_Call) Run(run func(ctx context.Context, callerID uuid.UUID, id uuid.UUID)) *MockAttachmentService_Open_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 uuid.UUID + if args[1] != nil { + arg1 = args[1].(uuid.UUID) + } + var arg2 uuid.UUID + if args[2] != nil { + arg2 = args[2].(uuid.UUID) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *MockAttachmentService_Open_Call) Return(attachment domain.Attachment, readCloser io.ReadCloser, err error) *MockAttachmentService_Open_Call { + _c.Call.Return(attachment, readCloser, err) + return _c +} + +func (_c *MockAttachmentService_Open_Call) RunAndReturn(run func(ctx context.Context, callerID uuid.UUID, id uuid.UUID) (domain.Attachment, io.ReadCloser, error)) *MockAttachmentService_Open_Call { + _c.Call.Return(run) + return _c +} + +// Presign provides a mock function for the type MockAttachmentService +func (_mock *MockAttachmentService) Presign(ctx context.Context, request domain.PresignRequest) (domain.PresignResult, error) { + ret := _mock.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for Presign") + } + + var r0 domain.PresignResult + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, domain.PresignRequest) (domain.PresignResult, error)); ok { + return returnFunc(ctx, request) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, domain.PresignRequest) domain.PresignResult); ok { + r0 = returnFunc(ctx, request) + } else { + r0 = ret.Get(0).(domain.PresignResult) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, domain.PresignRequest) error); ok { + r1 = returnFunc(ctx, request) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAttachmentService_Presign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Presign' +type MockAttachmentService_Presign_Call struct { + *mock.Call +} + +// Presign is a helper method to define mock.On call +// - ctx context.Context +// - request domain.PresignRequest +func (_e *MockAttachmentService_Expecter) Presign(ctx any, request any) *MockAttachmentService_Presign_Call { + return &MockAttachmentService_Presign_Call{Call: _e.mock.On("Presign", ctx, request)} +} + +func (_c *MockAttachmentService_Presign_Call) Run(run func(ctx context.Context, request domain.PresignRequest)) *MockAttachmentService_Presign_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 domain.PresignRequest + if args[1] != nil { + arg1 = args[1].(domain.PresignRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockAttachmentService_Presign_Call) Return(presignResult domain.PresignResult, err error) *MockAttachmentService_Presign_Call { + _c.Call.Return(presignResult, err) + return _c +} + +func (_c *MockAttachmentService_Presign_Call) RunAndReturn(run func(ctx context.Context, request domain.PresignRequest) (domain.PresignResult, error)) *MockAttachmentService_Presign_Call { + _c.Call.Return(run) + return _c +} + +// Upload provides a mock function for the type MockAttachmentService +func (_mock *MockAttachmentService) Upload(ctx context.Context, input attachment.UploadInput) (domain.Attachment, error) { + ret := _mock.Called(ctx, input) + + if len(ret) == 0 { + panic("no return value specified for Upload") + } + + var r0 domain.Attachment + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, attachment.UploadInput) (domain.Attachment, error)); ok { + return returnFunc(ctx, input) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, attachment.UploadInput) domain.Attachment); ok { + r0 = returnFunc(ctx, input) + } else { + r0 = ret.Get(0).(domain.Attachment) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, attachment.UploadInput) error); ok { + r1 = returnFunc(ctx, input) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAttachmentService_Upload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Upload' +type MockAttachmentService_Upload_Call struct { + *mock.Call +} + +// Upload is a helper method to define mock.On call +// - ctx context.Context +// - input attachment.UploadInput +func (_e *MockAttachmentService_Expecter) Upload(ctx any, input any) *MockAttachmentService_Upload_Call { + return &MockAttachmentService_Upload_Call{Call: _e.mock.On("Upload", ctx, input)} +} + +func (_c *MockAttachmentService_Upload_Call) Run(run func(ctx context.Context, input attachment.UploadInput)) *MockAttachmentService_Upload_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 attachment.UploadInput + if args[1] != nil { + arg1 = args[1].(attachment.UploadInput) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockAttachmentService_Upload_Call) Return(attachment1 domain.Attachment, err error) *MockAttachmentService_Upload_Call { + _c.Call.Return(attachment1, err) + return _c +} + +func (_c *MockAttachmentService_Upload_Call) RunAndReturn(run func(ctx context.Context, input attachment.UploadInput) (domain.Attachment, error)) *MockAttachmentService_Upload_Call { + _c.Call.Return(run) + return _c +} diff --git a/internal/transport/rest/mocks/SessionResolver.go b/internal/transport/rest/mocks/SessionResolver.go new file mode 100644 index 00000000..97796309 --- /dev/null +++ b/internal/transport/rest/mocks/SessionResolver.go @@ -0,0 +1,114 @@ +// Code generated by mockery; DO NOT EDIT. +// github.com/vektra/mockery +// template: testify + +package mocks + +import ( + "context" + "mtusi-messenger/internal/domain" + + mock "github.com/stretchr/testify/mock" +) + +// NewMockSessionResolver creates a new instance of MockSessionResolver. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockSessionResolver(t interface { + mock.TestingT + Cleanup(func()) +}) *MockSessionResolver { + if helper, ok := t.(interface{ Helper() }); ok { + helper.Helper() + } + + mock := &MockSessionResolver{} + mock.Mock.Test(t) + + t.Cleanup(func() { + if helper, ok := t.(interface{ Helper() }); ok { + helper.Helper() + } + mock.AssertExpectations(t) + }) + + return mock +} + +// MockSessionResolver is an autogenerated mock type for the SessionResolver type +type MockSessionResolver struct { + mock.Mock +} + +type MockSessionResolver_Expecter struct { + mock *mock.Mock +} + +func (_m *MockSessionResolver) EXPECT() *MockSessionResolver_Expecter { + return &MockSessionResolver_Expecter{mock: &_m.Mock} +} + +// Resolve provides a mock function for the type MockSessionResolver +func (_mock *MockSessionResolver) Resolve(ctx context.Context, token string) (domain.User, error) { + ret := _mock.Called(ctx, token) + + if len(ret) == 0 { + panic("no return value specified for Resolve") + } + + var r0 domain.User + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, string) (domain.User, error)); ok { + return returnFunc(ctx, token) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, string) domain.User); ok { + r0 = returnFunc(ctx, token) + } else { + r0 = ret.Get(0).(domain.User) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok { + r1 = returnFunc(ctx, token) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockSessionResolver_Resolve_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Resolve' +type MockSessionResolver_Resolve_Call struct { + *mock.Call +} + +// Resolve is a helper method to define mock.On call +// - ctx context.Context +// - token string +func (_e *MockSessionResolver_Expecter) Resolve(ctx any, token any) *MockSessionResolver_Resolve_Call { + return &MockSessionResolver_Resolve_Call{Call: _e.mock.On("Resolve", ctx, token)} +} + +func (_c *MockSessionResolver_Resolve_Call) Run(run func(ctx context.Context, token string)) *MockSessionResolver_Resolve_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 string + if args[1] != nil { + arg1 = args[1].(string) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockSessionResolver_Resolve_Call) Return(user domain.User, err error) *MockSessionResolver_Resolve_Call { + _c.Call.Return(user, err) + return _c +} + +func (_c *MockSessionResolver_Resolve_Call) RunAndReturn(run func(ctx context.Context, token string) (domain.User, error)) *MockSessionResolver_Resolve_Call { + _c.Call.Return(run) + return _c +} diff --git a/internal/transport/rest/router.go b/internal/transport/rest/router.go index cfa2833a..406368f3 100644 --- a/internal/transport/rest/router.go +++ b/internal/transport/rest/router.go @@ -10,8 +10,9 @@ import ( func NewRouter( handler oas.Handler, security oas.SecurityHandler, + extensions *Extensions, log *slog.Logger, - maxBodyBytes int64, + maxBodyBytes, maxUploadBytes int64, ) (http.Handler, error) { server, err := oas.NewServer( handler, @@ -25,7 +26,19 @@ func NewRouter( return nil, err } + mux := http.NewServeMux() + + if extensions != nil { + // These routes are an optional contract extension (presigned uploads). + // They live outside the generated server so contracts/openapi.json stays + // byte-identical to the mandatory contract. + mux.Handle("/api/v1/chats/{chat_id}/attachments/presign", extensions.Presign()) + mux.Handle("/api/v1/attachments/{attachment_id}/complete", extensions.Complete()) + } + + mux.Handle("/", server) + return requestIDMiddleware( - instanceIDMiddleware(InstanceID(), bodyLimitMiddleware(maxBodyBytes, log, server)), + instanceIDMiddleware(InstanceID(), bodyLimitMiddleware(maxBodyBytes, maxUploadBytes, log, mux)), ), nil } diff --git a/internal/transport/rest/router_test.go b/internal/transport/rest/router_test.go index 4419ada4..489913f8 100644 --- a/internal/transport/rest/router_test.go +++ b/internal/transport/rest/router_test.go @@ -44,11 +44,12 @@ type httpResult struct { } type routerFixture struct { - users *mocks.MockUserService - chats *mocks.MockChatService - messages *mocks.MockMessageService - health *mocks.MockHealthChecker - sessions *mocks.MockSessionActions + users *mocks.MockUserService + chats *mocks.MockChatService + messages *mocks.MockMessageService + attachments *mocks.MockAttachmentService + health *mocks.MockHealthChecker + sessions *mocks.MockSessionActions server *httptest.Server } @@ -60,18 +61,28 @@ func newRouterFixture(t *testing.T) *routerFixture { t.Helper() fixture := &routerFixture{ - users: mocks.NewMockUserService(t), - chats: mocks.NewMockChatService(t), - messages: mocks.NewMockMessageService(t), - health: mocks.NewMockHealthChecker(t), - sessions: mocks.NewMockSessionActions(t), + users: mocks.NewMockUserService(t), + chats: mocks.NewMockChatService(t), + messages: mocks.NewMockMessageService(t), + attachments: mocks.NewMockAttachmentService(t), + health: mocks.NewMockHealthChecker(t), + sessions: mocks.NewMockSessionActions(t), } router, err := rest.NewRouter( - rest.NewHandler(fixture.users, fixture.chats, fixture.messages, fixture.health, fixture.sessions), + rest.NewHandler( + fixture.users, + fixture.chats, + fixture.messages, + fixture.attachments, + fixture.health, + fixture.sessions, + ), rest.NewSecurityHandler(fixture.sessions), + nil, logger.New(logger.WithLevel(slog.LevelError)), testMaxBodyBytes, + testMaxBodyBytes, ) require.NoError(t, err) diff --git a/scripts/check_s3_creds.py b/scripts/check_s3_creds.py new file mode 100755 index 00000000..a1e78d98 --- /dev/null +++ b/scripts/check_s3_creds.py @@ -0,0 +1,71 @@ +#!/usr/bin/env python3 +"""Fail when the SeaweedFS identities and the API environment disagree. + +The stand keeps synthetic credentials in two places on purpose: the identities +file is mounted into SeaweedFS, while the API receives the same values through +the environment. This check keeps the copies from drifting. +""" +from __future__ import annotations + +import json +import sys +from pathlib import Path + +ROOT = Path(__file__).resolve().parent.parent +IDENTITIES = ROOT / "infra/s3/s3.json" + + +def parse_env(path: Path) -> dict[str, str]: + values: dict[str, str] = {} + for raw in path.read_text().splitlines(): + line = raw.strip() + if not line or line.startswith("#") or "=" not in line: + continue + key, value = line.split("=", 1) + values[key.strip()] = value.strip().strip('"').strip("'") + return values + + +def main() -> int: + identities = json.loads(IDENTITIES.read_text()) + by_name = {item["name"]: item for item in identities.get("identities", [])} + + source = ROOT / ".env" + if not source.is_file(): + source = ROOT / ".env.example" + env = parse_env(source) + + expected = { + "admin": ("S3_ADMIN_ACCESS_KEY", "S3_ADMIN_SECRET_ACCESS_KEY"), + "app": ("S3_ACCESS_KEY_ID", "S3_SECRET_ACCESS_KEY"), + } + + failures: list[str] = [] + for name, (key_var, secret_var) in expected.items(): + identity = by_name.get(name) + if identity is None: + failures.append(f"{IDENTITIES}: identity {name!r} is missing") + continue + credentials = identity.get("credentials") or [] + if not credentials: + failures.append(f"{IDENTITIES}: identity {name!r} has no credentials") + continue + access_key = credentials[0].get("accessKey") + secret_key = credentials[0].get("secretKey") + if env.get(key_var) != access_key: + failures.append(f"{source.name}: {key_var} does not match identity {name!r}") + if env.get(secret_var) != secret_key: + failures.append(f"{source.name}: {secret_var} does not match identity {name!r}") + + if failures: + print("FAIL: S3 credentials are inconsistent") + for failure in failures: + print(" -", failure) + return 1 + + print(f"PASS: S3 identities match {source.name} (admin + app)") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/scripts/lab4_memory_experiment.py b/scripts/lab4_memory_experiment.py new file mode 100755 index 00000000..f350ad04 --- /dev/null +++ b/scripts/lab4_memory_experiment.py @@ -0,0 +1,147 @@ +#!/usr/bin/env python3 +"""Measure API memory under concurrent 9 MiB uploads (lab4 level 4). + +Run against a live stand. Writes raw CSV samples and a summary under +evidence/lab4/memory/. The primary metric is cgroup anon memory: memory.current +also includes page cache from the temporary spool files. + + python3 scripts/lab4_memory_experiment.py --base-url http://localhost:8080 +""" +from __future__ import annotations + +import argparse +import csv +import os +import struct +import sys +import threading +import time +import zlib +from concurrent.futures import ThreadPoolExecutor +from pathlib import Path + +ROOT = Path(__file__).resolve().parent.parent +sys.path.insert(0, str(ROOT / 'tests')) + +from client import Client # noqa: E402 + +OUTPUT = ROOT / 'evidence/lab4/memory' + + +def png_of_size(width: int, height: int, seed: int) -> bytes: + """Build a valid, poorly compressible PNG (random RGB scanlines).""" + rng = __import__('random').Random(seed) + raw = bytearray() + for _ in range(height): + raw.append(0) # filter: None + raw.extend(rng.randbytes(width * 3)) + + def chunk(kind: bytes, data: bytes) -> bytes: + return struct.pack('>I', len(data)) + kind + data + struct.pack('>I', zlib.crc32(kind + data) & 0xFFFFFFFF) + + ihdr = struct.pack('>IIBBBBB', width, height, 8, 2, 0, 0, 0) + return b'\x89PNG\r\n\x1a\n' + chunk(b'IHDR', ihdr) + chunk(b'IDAT', zlib.compress(bytes(raw), 6)) + chunk(b'IEND', b'') + + +def containers(service: str) -> list[str]: + output = os.popen(f'docker compose ps -q {service}').read().split() + if not output: + raise SystemExit(f'no running containers for service {service}') + return output + + +def read_number(container: str, path: str) -> int: + output = os.popen(f'docker exec {container} cat {path} 2>/dev/null').read().strip() + return int(output) if output.isdigit() else 0 + + +def memory_snapshot() -> dict[str, int]: + api = containers('api') + anon = current = 0 + for container in api: + stats = os.popen(f'docker exec {container} cat /sys/fs/cgroup/memory.stat 2>/dev/null').read() + for line in stats.splitlines(): + if line.startswith('anon '): + anon += int(line.split()[1]) + current += read_number(container, '/sys/fs/cgroup/memory.current') + return {'anon': anon, 'current': current} + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument('--base-url', default='http://localhost:8080') + parser.add_argument('--concurrency', type=int, default=10) + parser.add_argument('--width', type=int, default=2100) + parser.add_argument('--height', type=int, default=1500) + parser.add_argument('--rounds', type=int, default=3) + args = parser.parse_args() + + content = png_of_size(args.width, args.height, 42) + if len(content) > 10 * 1024 * 1024: + raise SystemExit(f'generated PNG is {len(content)} bytes, above the 10 MiB contract limit') + + client = Client(args.base_url, timeout=120) + alice, _, _, chat = client.bootstrap() + + OUTPUT.mkdir(parents=True, exist_ok=True) + samples: list[dict[str, int | float | str]] = [] + stop = threading.Event() + + def sample(phase: str = 'during') -> None: + started = time.monotonic() + while not stop.is_set(): + snapshot = memory_snapshot() + samples.append({'elapsed': round(time.monotonic() - started, 3), 'phase': phase, **snapshot}) + time.sleep(0.2) + + baseline = memory_snapshot() + sampler = threading.Thread(target=sample, daemon=True) + sampler.start() + + def upload(_: int) -> None: + path = '/api/v1/chats/' + chat['id'] + '/attachments?filename=memory.png' + client.call( + 'POST', path, 201, actor=alice, raw=content, + headers={'Content-Type': 'image/png'}, schema='Attachment', + ) + + started = time.monotonic() + for _ in range(args.rounds): + with ThreadPoolExecutor(max_workers=args.concurrency) as pool: + list(pool.map(upload, range(args.concurrency))) + elapsed = time.monotonic() - started + + stop.set() + sampler.join(timeout=2) + after = memory_snapshot() + + peak_anon = max((int(item['anon']) for item in samples), default=after['anon']) + peak_current = max((int(item['current']) for item in samples), default=after['current']) + + csv_path = OUTPUT / 'samples.csv' + with csv_path.open('w', newline='') as handle: + writer = csv.DictWriter(handle, fieldnames=['elapsed', 'phase', 'anon', 'current']) + writer.writeheader() + writer.writerows(samples) + + summary = OUTPUT / 'summary.txt' + summary.write_text( + 'Lab4 memory experiment\n' + f'concurrency: {args.concurrency}\n' + f'file_size_bytes: {len(content)}\n' + f'uploads: {args.concurrency * args.rounds}\n' + f'rounds: {args.rounds}\n' + f'elapsed_seconds: {elapsed:.3f}\n' + f'baseline_anon_bytes: {baseline["anon"]}\n' + f'peak_anon_bytes: {peak_anon}\n' + f'anon_delta_bytes: {peak_anon - baseline["anon"]}\n' + f'peak_memory_current_bytes: {peak_current}\n' + 'note: memory.current includes page cache from temporary spool files; anon is the primary metric\n' + ) + + print(summary.read_text()) + print('CSV:', csv_path) + + +if __name__ == '__main__': + main() diff --git a/scripts/lab4_track1.py b/scripts/lab4_track1.py new file mode 100755 index 00000000..4a86e8c6 --- /dev/null +++ b/scripts/lab4_track1.py @@ -0,0 +1,179 @@ +#!/usr/bin/env python3 +"""Compare proxy upload with presigned direct upload (lab4 track 1). + +Measures client-facing LB traffic, API traffic, API anon memory and latency for +two file sizes. Run against a live stand from the repository root. + + python3 scripts/lab4_track1.py --base-url http://localhost:8080 +""" +from __future__ import annotations + +import argparse +import csv +import os +import statistics +import sys +import threading +import time +from pathlib import Path + +ROOT = Path(__file__).resolve().parent.parent +sys.path.insert(0, str(ROOT / 'tests')) +sys.path.insert(0, str(ROOT / 'student-tests')) + +from client import Client # noqa: E402 +from presign_flow import complete, presign, put # noqa: E402 +from lab4_memory_experiment import png_of_size # noqa: E402 + +OUTPUT = ROOT / 'evidence/lab4/track1' + + +def containers(service: str) -> list[str]: + ids = os.popen(f'docker compose ps -q {service}').read().split() + if not ids: + raise SystemExit(f'no running containers for service {service}') + return ids + + +def read_net(service: str) -> tuple[int, int]: + rx = tx = 0 + for container in containers(service): + for direction, path in (('rx', 'rx_bytes'), ('tx', 'tx_bytes')): + value = os.popen( + f'docker exec {container} cat /sys/class/net/eth0/statistics/{path} 2>/dev/null' + ).read().strip() + if value.isdigit(): + if direction == 'rx': + rx += int(value) + else: + tx += int(value) + return rx, tx + + +def read_anon() -> int: + total = 0 + for container in containers('api'): + stats = os.popen(f'docker exec {container} cat /sys/fs/cgroup/memory.stat 2>/dev/null').read() + for line in stats.splitlines(): + if line.startswith('anon '): + total += int(line.split()[1]) + return total + + +class Sampler: + def __init__(self) -> None: + self.stop = threading.Event() + self.peak = 0 + self.thread = threading.Thread(target=self.run, daemon=True) + + def run(self) -> None: + while not self.stop.is_set(): + self.peak = max(self.peak, read_anon()) + time.sleep(0.1) + + def __enter__(self) -> 'Sampler': + self.thread.start() + return self + + def __exit__(self, *_args: object) -> None: + self.stop.set() + self.thread.join(timeout=2) + + +def proxy_upload(client: Client, actor: dict, chat: dict, content: bytes) -> None: + path = '/api/v1/chats/' + chat['id'] + '/attachments?filename=track1.png' + client.call( + 'POST', path, 201, actor=actor, raw=content, + headers={'Content-Type': 'image/png'}, schema='Attachment', + ) + + +def presign_upload(client: Client, actor: dict, chat: dict, content: bytes) -> None: + prepared = presign(client, actor, chat, content) + status = put(prepared['upload_url'], content) + if status != 200: + raise SystemExit(f'presigned PUT failed with {status}') + complete(client, actor, prepared['attachment_id'], prepared['sha256']) + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument('--base-url', default='http://localhost:8080') + parser.add_argument('--iterations', type=int, default=5) + args = parser.parse_args() + + client = Client(args.base_url, timeout=180) + alice, _, _, chat = client.bootstrap() + + files = { + '~1MiB': png_of_size(700, 500, 11), + '~9MiB': png_of_size(2100, 1500, 12), + } + + OUTPUT.mkdir(parents=True, exist_ok=True) + rows: list[dict[str, object]] = [] + + for label, content in files.items(): + for flow, operation in (('proxy', proxy_upload), ('presign', presign_upload)): + for iteration in range(args.iterations): + lb_before, lb_tx_before = read_net('lb') + api_before, api_tx_before = read_net('api') + started = time.monotonic() + + with Sampler() as sampler: + operation(client, alice, chat, content) + + latency = time.monotonic() - started + lb_after, lb_tx_after = read_net('lb') + api_after, api_tx_after = read_net('api') + + rows.append({ + 'size': label, + 'bytes': len(content), + 'flow': flow, + 'iteration': iteration, + 'latency_s': round(latency, 4), + 'lb_rx_bytes': lb_after - lb_before, + 'lb_tx_bytes': lb_tx_after - lb_tx_before, + 'api_rx_bytes': api_after - api_before, + 'api_tx_bytes': api_tx_after - api_tx_before, + 'api_anon_peak': sampler.peak, + }) + + csv_path = OUTPUT / 'results.csv' + with csv_path.open('w', newline='') as handle: + writer = csv.DictWriter(handle, fieldnames=list(rows[0])) + writer.writeheader() + writer.writerows(rows) + + lines = ['Lab4 track 1: proxy vs presigned upload', ''] + lines.append('| size | flow | median latency, s | p95 latency, s | LB rx, bytes | API rx, bytes | API anon peak, bytes |') + lines.append('|---|---|---:|---:|---:|---:|---:|') + for label in files: + for flow in ('proxy', 'presign'): + group = [row for row in rows if row['size'] == label and row['flow'] == flow] + latencies = sorted(float(row['latency_s']) for row in group) + median = statistics.median(latencies) + p95 = latencies[min(len(latencies) - 1, int(round(0.95 * (len(latencies) - 1))))] + lb_rx = sum(int(row['lb_rx_bytes']) for row in group) / len(group) + api_rx = sum(int(row['api_rx_bytes']) for row in group) / len(group) + peak = max(int(row['api_anon_peak']) for row in group) + lines.append( + f'| {label} | {flow} | {median:.3f} | {p95:.3f} | {lb_rx:.0f} | {api_rx:.0f} | {peak} |' + ) + + lines += [ + '', + 'Note: presigned upload keeps the file body off the API request path and off the load balancer.', + 'Completion still streams the object from S3 once to verify its SHA-256, so api_rx stays close to', + 'the file size; the saving is in the client-facing LB leg and in not accepting/buffering the body.', + '', + ] + summary = OUTPUT / 'summary.txt' + summary.write_text('\n'.join(lines)) + print(summary.read_text()) + print('CSV:', csv_path) + + +if __name__ == '__main__': + main() diff --git a/scripts/lb_readiness_check.sh b/scripts/lb_readiness_check.sh index 23628a8c..1b163d60 100755 --- a/scripts/lb_readiness_check.sh +++ b/scripts/lb_readiness_check.sh @@ -24,9 +24,9 @@ if [ -f .env ]; then fi OUT=${OUT:-evidence/lb-readiness.txt} -PROJECT=${COMPOSE_PROJECT_NAME:-mtusi-messenger-lab3} +PROJECT=${COMPOSE_PROJECT_NAME:-mtusi-messenger-lab4} NET=${PROJECT}_default -IMAGE=${IMAGE:-mtusi-messenger:lab3} +IMAGE=${IMAGE:-mtusi-messenger:lab4} STATS=${STATS:-http://127.0.0.1:8404/stats;csv} BASE_URL=${BASE_URL:-http://localhost:8080} CANDIDATE=lb-readiness-candidate diff --git a/scripts/restart.sh b/scripts/restart.sh index c8ce6dc6..3767d829 100755 --- a/scripts/restart.sh +++ b/scripts/restart.sh @@ -1,6 +1,6 @@ #!/bin/sh set -eu -# Restart hook: bounce API replicas and every state store of the lab3 stand. +# Restart hook: bounce API replicas and every state store of the lab4 stand. # # scripts/restart.sh # @@ -31,9 +31,9 @@ compose() { # 1. State stores: restart the running ones, then make sure they are healthy. # Volumes are attached as before, nothing is dropped or re-seeded. -compose up -d --wait postgres redis -compose restart postgres redis -compose up -d --wait postgres redis +compose up -d --wait postgres redis seaweedfs +compose restart postgres redis seaweedfs +compose up -d --wait postgres redis seaweedfs # 2. API replicas: restart in place (same containers, same addresses) and bring # back any replica that was stopped by the fault-injection hook. diff --git a/scripts/rolling_update.sh b/scripts/rolling_update.sh index 6d664a83..934a9ba7 100755 --- a/scripts/rolling_update.sh +++ b/scripts/rolling_update.sh @@ -25,8 +25,8 @@ DURATION=${DURATION:-60} CONCURRENCY=${CONCURRENCY:-8} BASE_URL=${BASE_URL:-http://localhost:8080} OUT=${OUT:-evidence/rolling-update} -IMAGE=${IMAGE:-mtusi-messenger:lab3} -PROJECT=${COMPOSE_PROJECT_NAME:-mtusi-messenger-lab3} +IMAGE=${IMAGE:-mtusi-messenger:lab4} +PROJECT=${COMPOSE_PROJECT_NAME:-mtusi-messenger-lab4} NET=${PROJECT}_default STATS=${STATS:-http://127.0.0.1:8404/stats;csv} PREFIX=lb-rollout diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh index 3d7ff430..3f3d5fb8 100755 --- a/scripts/stop-one.sh +++ b/scripts/stop-one.sh @@ -1,6 +1,6 @@ #!/bin/sh set -eu -# Fault-injection hook: stop exactly ONE api replica of the lab3 stand. +# Fault-injection hook: stop exactly ONE api replica of the lab4 stand. # # TARGET_INSTANCE_ID= scripts/stop-one.sh # @@ -13,7 +13,7 @@ set -eu # No credentials are printed. : "${TARGET_INSTANCE_ID:?test provides target API instance alias}" -PROJECT=${COMPOSE_PROJECT_NAME:-mtusi-messenger-lab3} +PROJECT=${COMPOSE_PROJECT_NAME:-mtusi-messenger-lab4} candidates=$(docker ps -q \ --filter "label=com.docker.compose.project=${PROJECT}" \ @@ -26,7 +26,7 @@ fi # Matches the requested alias against every reasonable identifier of a replica: # container hostname (= X-Instance-Id), full/short container id, full container -# name (mtusi-messenger-lab3-api-1) and the service-local suffix (api-1). +# name (mtusi-messenger-lab4-api-1) and the service-local suffix (api-1). match_replica() { target=$1 full_id=$2 diff --git a/student-tests/attachment_failover.py b/student-tests/attachment_failover.py new file mode 100755 index 00000000..b0138110 --- /dev/null +++ b/student-tests/attachment_failover.py @@ -0,0 +1,80 @@ +#!/usr/bin/env python3 +"""Upload through one API replica, stop it, download through another. + +Run against a live stand: + python3 student-tests/attachment_failover.py --base-url http://localhost:8080 +""" +import hashlib +import os +import subprocess +import sys +import time +from pathlib import Path +from urllib.parse import quote + +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'tests')) +sys.path.insert(0, str(Path(__file__).resolve().parent)) + +from client import Client, Failure, arguments, check, run # noqa: E402 +from tests_helpers import ROOT, compose # noqa: E402 + +FIXTURE = Path(__file__).resolve().parents[1] / 'tests/fixtures/sample.png' + + +def main(): + args = arguments('Attachment failover across API replicas (lab4)') + client = Client(args.base_url, args.ca_file) + alice, bob, _, chat = client.bootstrap() + content = FIXTURE.read_bytes() + + response = client.call( + 'POST', + '/api/v1/chats/' + chat['id'] + '/attachments?filename=' + quote('failover.png'), + 201, + actor=alice, + raw=content, + headers={'Content-Type': 'image/png'}, + schema='Attachment', + ) + attachment = response['json'] + instance = response['headers'].get('X-Instance-Id') + check(bool(instance), 'upload response has no X-Instance-Id') + check(attachment['sha256'] == hashlib.sha256(content).hexdigest(), 'upload checksum mismatch') + + stop = subprocess.run( + [str(ROOT / 'scripts/stop-one.sh')], + cwd=ROOT, + env={**os.environ, 'TARGET_INSTANCE_ID': instance}, + capture_output=True, + text=True, + ) + check(stop.returncode == 0, 'stop-one.sh failed: ' + stop.stderr.strip()) + + deadline = time.monotonic() + 30 + last_error = None + while time.monotonic() < deadline: + try: + download = client.call( + 'GET', '/api/v1/attachments/' + attachment['id'] + '/content', actor=bob, + ) + if download['bytes'] == content: + metadata = client.call( + 'GET', '/api/v1/attachments/' + attachment['id'], actor=bob, schema='Attachment', + )['json'] + check(metadata['sha256'] == attachment['sha256'], 'metadata changed after failover') + print('PASS: lab4 attachment failover; served by', instance) + return + last_error = 'downloaded bytes differ from the original' + except Failure as error: + last_error = str(error) + + time.sleep(1) + + raise Failure('download did not recover within 30s: ' + str(last_error)) + + +if __name__ == '__main__': + try: + run(main) + finally: + compose('up', '-d', '--no-deps', 'api', check=False) diff --git a/student-tests/attachments_negative.py b/student-tests/attachments_negative.py new file mode 100755 index 00000000..0e5dc872 --- /dev/null +++ b/student-tests/attachments_negative.py @@ -0,0 +1,107 @@ +#!/usr/bin/env python3 +"""Negative attachment scenarios required by lab4 level 4. + +Run against a live stand: + python3 student-tests/attachments_negative.py --base-url http://localhost:8080 +""" +import hashlib +import sys +import urllib.error +import urllib.request +import uuid +from pathlib import Path +from urllib.parse import quote + +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'tests')) + +from client import Client, Failure, arguments, check, run # noqa: E402 + +FIXTURE = Path(__file__).resolve().parents[1] / 'tests/fixtures/sample.png' + + +def upload(client, actor, chat, content, filename='sample.png', content_type='image/png', expected=201): + path = '/api/v1/chats/' + chat['id'] + '/attachments?filename=' + quote(filename, safe='') + return client.call('POST', path, expected, actor=actor, raw=content, headers={'Content-Type': content_type}) + + +def main(): + args = arguments('Attachment negative scenarios (lab4)') + client = Client(args.base_url, args.ca_file) + alice, bob, eve, chat = client.bootstrap() + fixture = FIXTURE.read_bytes() + + # Oversized body: rejected before any image parsing. + upload(client, alice, chat, b'\x00' * (10 * 1024 * 1024 + 1), expected=413) + + # Empty body is not a valid image. + upload(client, alice, chat, b'', expected=415) + + # Corrupt PNG: flip one IDAT payload byte, CRC no longer matches. + corrupt = bytearray(fixture) + index = corrupt.index(b'IDAT') + 8 + corrupt[index] ^= 0xFF + upload(client, alice, chat, bytes(corrupt), expected=415) + + # Declared JPEG but the bytes are PNG. + upload(client, alice, chat, fixture, filename='photo.jpg', content_type='image/jpeg', expected=415) + + # Dangerous display names. + for name in ('../x.png', 'a/b.png', 'a\\b.png', 'a\x00.png', 'a\n.png'): + upload(client, alice, chat, fixture, filename=name, expected=400) + + # A member of one chat cannot read an attachment of another chat. + other = client.call( + 'POST', '/api/v1/chats', 201, actor=alice, + body={'title': 'Другой чат', 'member_ids': [alice['id'], eve['id']]}, schema='Chat', + )['json'] + foreign, foreign_content = client.attachment(eve, other) + client.call('GET', '/api/v1/attachments/' + foreign['id'], 404, actor=bob) + client.call('GET', '/api/v1/attachments/' + foreign['id'] + '/content', 404, actor=bob) + + # Message rules: empty text without attachments, attachment from another chat. + client.call( + 'POST', '/api/v1/chats/' + chat['id'] + '/messages', 400, actor=alice, + body={'text': ''}, headers={'Idempotency-Key': uuid.uuid4().hex}, + ) + client.call( + 'POST', '/api/v1/chats/' + chat['id'] + '/messages', 404, actor=alice, + body={'text': 'чужое', 'attachment_ids': [foreign['id']]}, + headers={'Idempotency-Key': uuid.uuid4().hex}, + ) + + # Contract limits: 11 unique IDs and duplicate IDs are rejected by the schema. + client.call( + 'POST', '/api/v1/chats/' + chat['id'] + '/messages', 400, actor=alice, + body={'text': 'много', 'attachment_ids': [str(uuid.uuid4()) for _ in range(11)]}, + headers={'Idempotency-Key': uuid.uuid4().hex}, + ) + duplicate = str(uuid.uuid4()) + client.call( + 'POST', '/api/v1/chats/' + chat['id'] + '/messages', 400, actor=alice, + body={'text': 'дубликат', 'attachment_ids': [duplicate, duplicate]}, + headers={'Idempotency-Key': uuid.uuid4().hex}, + ) + + # The only variant in the lab4 contract is original; other values are 400. + own, content = client.attachment(alice, chat) + client.call('GET', '/api/v1/attachments/' + own['id'] + '/content?variant=thumbnail', 400, actor=alice) + + # Attachment-only message is valid. + client.message(alice, chat, '', attachments=[own['id']]) + + # Object keys are server-generated; anonymous direct access must be denied. + key = 'attachments/' + chat['id'] + '/' + own['id'] + request = urllib.request.Request('http://127.0.0.1:8333/messenger-attachments/' + key, method='GET') + try: + urllib.request.urlopen(request, timeout=5) + except urllib.error.HTTPError as error: + check(error.code == 403, 'anonymous S3 GET must be 403, got ' + str(error.code)) + else: + raise Failure('anonymous S3 GET unexpectedly succeeded') + + check(hashlib.sha256(content).hexdigest() == own['sha256'], 'fixture checksum mismatch') + print('PASS: lab4 attachment negative scenarios') + + +if __name__ == '__main__': + run(main) diff --git a/student-tests/presign_flow.py b/student-tests/presign_flow.py new file mode 100755 index 00000000..8713fde5 --- /dev/null +++ b/student-tests/presign_flow.py @@ -0,0 +1,135 @@ +#!/usr/bin/env python3 +"""Presigned direct-upload track (lab4 level 5). + +The mandatory proxy endpoint stays available; this script exercises the +optional extension: presign -> direct PUT to S3 -> complete -> message. + +Run against a live stand: + python3 student-tests/presign_flow.py --base-url http://localhost:8080 + +Set PRESIGN_EXPIRY_WAIT=seconds to also verify that an expired URL is rejected +(the stand must run with a matching S3_PRESIGN_TTL). +""" +import hashlib +import json +import os +import sys +import time +import urllib.error +import urllib.request +import uuid +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'tests')) + +from client import Client, Failure, arguments, check, run # noqa: E402 + +FIXTURE = Path(__file__).resolve().parents[1] / 'tests/fixtures/sample.png' + + +def presign(client, actor, chat, content, filename='presigned.png', content_type='image/png'): + body = { + 'filename': filename, + 'content_type': content_type, + 'size_bytes': len(content), + 'sha256': hashlib.sha256(content).hexdigest(), + } + response = client.call( + 'POST', '/api/v1/chats/' + chat['id'] + '/attachments/presign', 201, + actor=actor, body=body, + ) + return json.loads(response['bytes']) + + +def put(url, content, content_type='image/png'): + request = urllib.request.Request( + url, data=content, method='PUT', headers={'Content-Type': content_type}, + ) + try: + with urllib.request.urlopen(request, timeout=15) as response: + return response.status + except urllib.error.HTTPError as error: + return error.code + + +def complete(client, actor, attachment_id, digest, expected=200): + return client.call( + 'POST', '/api/v1/attachments/' + attachment_id + '/complete', expected, + actor=actor, body={'sha256': digest}, schema='Attachment' if expected == 200 else None, + ) + + +def main(): + args = arguments('Presigned upload flow (lab4 track 1)') + client = Client(args.base_url, args.ca_file) + alice, bob, eve, chat = client.bootstrap() + content = FIXTURE.read_bytes() + digest = hashlib.sha256(content).hexdigest() + + # Happy path: direct PUT, completion, message, download. + presigned = presign(client, alice, chat, content) + check(presigned['method'] == 'PUT', 'presign method must be PUT') + check(put(presigned['upload_url'], content) == 200, 'direct PUT failed') + attachment = complete(client, alice, presigned['attachment_id'], digest)['json'] + check(attachment['sha256'] == digest and attachment['size_bytes'] == len(content), 'completed metadata mismatch') + + client.message(alice, chat, '', attachments=[attachment['id']]) + download = client.call('GET', '/api/v1/attachments/' + attachment['id'] + '/content', actor=bob) + check(download['bytes'] == content, 'download differs from the presigned original') + + # Completion is idempotent. + again = complete(client, alice, presigned['attachment_id'], digest)['json'] + check(again['id'] == attachment['id'], 'repeated complete returned another attachment') + + # A foreign user cannot complete someone else's pending upload. + pending = presign(client, alice, chat, content) + complete(client, bob, pending['attachment_id'], digest, expected=404) + + # Incomplete upload: complete before PUT. + incomplete = presign(client, alice, chat, content) + complete(client, alice, incomplete['attachment_id'], digest, expected=409) + + # Wrong checksum: the object is rejected and removed. + mismatch = presign(client, alice, chat, content) + check(put(mismatch['upload_url'], content) == 200, 'direct PUT failed') + complete(client, alice, mismatch['attachment_id'], '0' * 64, expected=409) + + # Declared size is enforced at completion, after the direct PUT. + oversized = presign(client, alice, chat, content) + check(put(oversized['upload_url'], content + b'x') == 200, 'direct PUT failed') + complete(client, alice, oversized['attachment_id'], digest, expected=400) + + # Last PUT wins before completion; the declared checksum must describe it. + overwrite = presign(client, alice, chat, content) + check(put(overwrite['upload_url'], b'not an image') == 200, 'first PUT failed') + check(put(overwrite['upload_url'], content) == 200, 'second PUT failed') + overwritten = complete(client, alice, overwrite['attachment_id'], digest)['json'] + check(overwritten['sha256'] == digest, 'last PUT was not the completed object') + + # A user outside the chat cannot obtain a presigned URL. + other = client.call( + 'POST', '/api/v1/chats', 201, actor=alice, + body={'title': 'Приватный чат', 'member_ids': [alice['id'], eve['id']]}, schema='Chat', + )['json'] + client.call( + 'POST', '/api/v1/chats/' + other['id'] + '/attachments/presign', 404, + actor=bob, + body={ + 'filename': 'x.png', 'content_type': 'image/png', + 'size_bytes': len(content), 'sha256': digest, + }, + ) + + wait = float(os.environ.get('PRESIGN_EXPIRY_WAIT', '0')) + if wait > 0: + expired = presign(client, alice, chat, content) + time.sleep(wait) + status = put(expired['upload_url'], content) + check(status == 403, 'expired presigned URL must be 403, got ' + str(status)) + print('EXPIRED: presigned URL rejected after', wait, 'seconds') + + print('PASS: lab4 presigned upload flow') + + +if __name__ == '__main__': + run(main) diff --git a/student-tests/tests_helpers.py b/student-tests/tests_helpers.py index c4db7963..dcbb55c9 100644 --- a/student-tests/tests_helpers.py +++ b/student-tests/tests_helpers.py @@ -18,7 +18,7 @@ def compose(*args, check=True): def containers_by_hostname(service='api'): """{hostname: {id, name, status}} для контейнеров сервиса.""" - project = os.environ.get('COMPOSE_PROJECT_NAME', 'mtusi-messenger-lab3') + project = os.environ.get('COMPOSE_PROJECT_NAME', 'mtusi-messenger-lab4') listed = subprocess.run( [ 'docker', 'ps', '-q', diff --git a/tools/specgen/main.go b/tools/specgen/main.go new file mode 100644 index 00000000..cb531e62 --- /dev/null +++ b/tools/specgen/main.go @@ -0,0 +1,177 @@ +// Command specgen produces the OpenAPI document used for code generation. +// +// The mandatory contract (contracts/openapi.json, version 1.4.0) describes the +// cross-field rule "text is non-empty OR attachment_ids is non-empty" with an +// anyOf. ogen v1.24 cannot generate Go types for two unnamed anyOf branches +// with the same name; ignoring the limitation silently drops entire operations. +// This tool removes exactly those two anyOf constraints from a derived document +// and fails on any other union, so a contract change cannot silently weaken +// code generation. The canonical contract is never modified; the application +// enforces the cross-field rule itself. +package main + +import ( + "bytes" + "encoding/json" + "errors" + "flag" + "fmt" + "os" + "path/filepath" + "strconv" +) + +const ( + contractPath = "contracts/openapi.json" + labPath = "lab.json" + outputPath = ".cache/openapi.codegen.json" +) + +var rewriteTargets = [][]string{ + {"components", "schemas", "Message"}, + {"components", "schemas", "CreateMessage"}, +} + +func main() { + check := flag.Bool("check", false, "verify that the derived document matches the generated file") + flag.Parse() + + derived, err := derive() + if err != nil { + fail(err) + } + + if *check { + current, err := os.ReadFile(outputPath) + if err != nil { + fail(fmt.Errorf("read %s (run make generate-api first): %w", outputPath, err)) + } + + if !bytes.Equal(current, derived) { + fail(fmt.Errorf("%s is stale: run make generate-api", outputPath)) + } + + return + } + + if err := os.MkdirAll(filepath.Dir(outputPath), 0o750); err != nil { + fail(fmt.Errorf("create cache directory: %w", err)) + } + + if err := os.WriteFile(outputPath, derived, 0o600); err != nil { + fail(fmt.Errorf("write %s: %w", outputPath, err)) + } +} + +func derive() ([]byte, error) { + lab, err := readObject(labPath) + if err != nil { + return nil, err + } + + spec, err := readObject(contractPath) + if err != nil { + return nil, err + } + + contractVersion, _ := lab["contract_version"].(string) + if contractVersion == "" { + return nil, fmt.Errorf("%s: contract_version is missing", labPath) + } + + info, _ := spec["info"].(map[string]any) + version, _ := info["version"].(string) + if version != contractVersion { + return nil, fmt.Errorf( + "contract version mismatch: %s has %q, %s has %q", + labPath, contractVersion, contractPath, version, + ) + } + + number, _ := lab["number"].(float64) + if number != 4 { + return nil, fmt.Errorf("%s: expected lab number 4, got %v", labPath, lab["number"]) + } + + for _, path := range rewriteTargets { + schema, err := lookup(spec, path...) + if err != nil { + return nil, err + } + + if _, ok := schema["anyOf"]; !ok { + return nil, fmt.Errorf("%s: anyOf is missing; re-check the codegen workaround", filepath.Join(path...)) + } + + delete(schema, "anyOf") + } + + if err := rejectRemainingUnions(spec, nil); err != nil { + return nil, err + } + + encoded, err := json.MarshalIndent(spec, "", " ") + if err != nil { + return nil, fmt.Errorf("encode derived document: %w", err) + } + + return append(encoded, '\n'), nil +} + +func readObject(path string) (map[string]any, error) { + raw, err := os.ReadFile(path) + if err != nil { + return nil, fmt.Errorf("read %s: %w", path, err) + } + + var object map[string]any + if err := json.Unmarshal(raw, &object); err != nil { + return nil, fmt.Errorf("parse %s: %w", path, err) + } + + return object, nil +} + +func lookup(root map[string]any, path ...string) (map[string]any, error) { + current := root + + for _, key := range path { + next, ok := current[key].(map[string]any) + if !ok { + return nil, fmt.Errorf("%s: object is missing", filepath.Join(path...)) + } + + current = next + } + + return current, nil +} + +func rejectRemainingUnions(value any, path []string) error { + switch typed := value.(type) { + case map[string]any: + for key, child := range typed { + if key == "anyOf" || key == "oneOf" { + return errors.New("unsupported union at " + filepath.Join(append(path, key)...) + + ": extend the codegen workaround explicitly") + } + + if err := rejectRemainingUnions(child, append(path, key)); err != nil { + return err + } + } + case []any: + for index, child := range typed { + if err := rejectRemainingUnions(child, append(path, strconv.Itoa(index))); err != nil { + return err + } + } + } + + return nil +} + +func fail(err error) { + fmt.Fprintln(os.Stderr, "specgen:", err) + os.Exit(1) +}