Merge branch 'dev' into dev-karas

Need to update the openapi documentation.

modules/auth/handlers/handlers.go

@@ -0,0 +1,238 @@
+package handlers
+
+import (
+	"context"
+	"crypto/rand"
+	"encoding/base64"
+	"fmt"
+	"net/http"
+	auth "nyanimedb/auth"
+	sqlc "nyanimedb/sql"
+	"strconv"
+	"time"
+
+	"github.com/alexedwards/argon2id"
+	"github.com/gin-gonic/gin"
+	"github.com/golang-jwt/jwt/v5"
+	log "github.com/sirupsen/logrus"
+)
+
+type Server struct {
+	db            *sqlc.Queries
+	JwtPrivateKey string
+}
+
+func NewServer(db *sqlc.Queries, JwtPrivatekey string) Server {
+	return Server{db: db, JwtPrivateKey: JwtPrivatekey}
+}
+
+func parseInt64(s string) (int32, error) {
+	i, err := strconv.ParseInt(s, 10, 64)
+	return int32(i), err
+}
+
+func HashPassword(password string) (string, error) {
+	params := &argon2id.Params{
+		Memory:      64 * 1024,
+		Iterations:  3,
+		Parallelism: 2,
+		SaltLength:  16,
+		KeyLength:   32,
+	}
+
+	return argon2id.CreateHash(password, params)
+}
+
+func CheckPassword(password, hash string) (bool, error) {
+	return argon2id.ComparePasswordAndHash(password, hash)
+}
+
+func (s Server) generateTokens(userID string) (accessToken string, refreshToken string, csrfToken string, err error) {
+	accessClaims := jwt.MapClaims{
+		"user_id": userID,
+		"exp":     time.Now().Add(15 * time.Minute).Unix(),
+	}
+	at := jwt.NewWithClaims(jwt.SigningMethodHS256, accessClaims)
+	accessToken, err = at.SignedString([]byte(s.JwtPrivateKey))
+	if err != nil {
+		return "", "", "", err
+	}
+
+	refreshClaims := jwt.MapClaims{
+		"user_id": userID,
+		"exp":     time.Now().Add(7 * 24 * time.Hour).Unix(),
+	}
+	rt := jwt.NewWithClaims(jwt.SigningMethodHS256, refreshClaims)
+	refreshToken, err = rt.SignedString([]byte(s.JwtPrivateKey))
+	if err != nil {
+		return "", "", "", err
+	}
+
+	csrfBytes := make([]byte, 32)
+	_, err = rand.Read(csrfBytes)
+	if err != nil {
+		return "", "", "", err
+	}
+	csrfToken = base64.RawURLEncoding.EncodeToString(csrfBytes)
+
+	return accessToken, refreshToken, csrfToken, nil
+}
+
+func (s Server) PostSignUp(ctx context.Context, req auth.PostSignUpRequestObject) (auth.PostSignUpResponseObject, error) {
+	passhash, err := HashPassword(req.Body.Pass)
+	if err != nil {
+		log.Errorf("failed to hash password: %v", err)
+		// TODO: return 500
+	}
+
+	user_id, err := s.db.CreateNewUser(context.Background(), sqlc.CreateNewUserParams{
+		Passhash: passhash,
+		Nickname: req.Body.Nickname,
+	})
+	if err != nil {
+		log.Errorf("failed to create user %s: %v", req.Body.Nickname, err)
+		// TODO: check err and retyrn 400/500
+	}
+
+	return auth.PostSignUp200JSONResponse{
+		UserId: user_id,
+	}, nil
+}
+
+func (s Server) PostSignIn(ctx context.Context, req auth.PostSignInRequestObject) (auth.PostSignInResponseObject, error) {
+	ginCtx, ok := ctx.Value(gin.ContextKey).(*gin.Context)
+	if !ok {
+		log.Print("failed to get gin context")
+		// TODO: change to 500
+		return auth.PostSignIn200JSONResponse{}, fmt.Errorf("failed to get gin.Context from context.Context")
+	}
+
+	user, err := s.db.GetUserByNickname(context.Background(), req.Body.Nickname)
+	if err != nil {
+		log.Errorf("failed to get user by nickname %s: %v", req.Body.Nickname, err)
+		// TODO: return 400/500
+	}
+
+	ok, err = CheckPassword(req.Body.Pass, user.Passhash)
+	if err != nil {
+		log.Errorf("failed to check password for user %s: %v", req.Body.Nickname, err)
+		// TODO: return 500
+	}
+	if !ok {
+		err_msg := "invalid credentials"
+		return auth.PostSignIn401JSONResponse{
+			Error: &err_msg,
+		}, nil
+	}
+
+	accessToken, refreshToken, csrfToken, err := s.generateTokens(req.Body.Nickname)
+	if err != nil {
+		log.Errorf("failed to generate tokens for user %s: %v", req.Body.Nickname, err)
+		// TODO: return 500
+	}
+
+	// TODO: check cookie settings carefully
+	ginCtx.SetSameSite(http.SameSiteStrictMode)
+	ginCtx.SetCookie("access_token", accessToken, 900, "/api", "", false, true)
+	ginCtx.SetCookie("refresh_token", refreshToken, 1209600, "/auth", "", false, true)
+	ginCtx.SetCookie("xsrf_token", csrfToken, 1209600, "/", "", false, false)
+
+	result := auth.PostSignIn200JSONResponse{
+		UserId:   user.ID,
+		UserName: user.Nickname,
+	}
+	return result, nil
+}
+
+// func (s Server) PostAuthVerifyToken(ctx context.Context, req auth.PostAuthVerifyTokenRequestObject) (auth.PostAuthVerifyTokenResponseObject, error) {
+// 	valid := false
+// 	var userID *string
+// 	var errStr *string
+
+// 	token, err := jwt.Parse(req.Body.Token, func(t *jwt.Token) (interface{}, error) {
+// 		if _, ok := t.Method.(*jwt.SigningMethodHMAC); !ok {
+// 			return nil, fmt.Errorf("unexpected signing method")
+// 		}
+// 		return accessSecret, nil
+// 	})
+
+// 	if err != nil {
+// 		e := err.Error()
+// 		errStr = &e
+// 		return auth.PostAuthVerifyToken200JSONResponse{
+// 			Valid:  &valid,
+// 			UserId: userID,
+// 			Error:  errStr,
+// 		}, nil
+// 	}
+
+// 	if claims, ok := token.Claims.(jwt.MapClaims); ok && token.Valid {
+// 		if uid, ok := claims["user_id"].(string); ok {
+// 			valid = true
+// 			userID = &uid
+// 		} else {
+// 			e := "user_id not found in token"
+// 			errStr = &e
+// 		}
+// 	} else {
+// 		e := "invalid token claims"
+// 		errStr = &e
+// 	}
+
+// 	return auth.PostAuthVerifyToken200JSONResponse{
+// 		Valid:  &valid,
+// 		UserId: userID,
+// 		Error:  errStr,
+// 	}, nil
+// }
+
+// func (s Server) PostAuthRefreshToken(ctx context.Context, req auth.PostAuthRefreshTokenRequestObject) (auth.PostAuthRefreshTokenResponseObject, error) {
+// 	valid := false
+// 	var userID *string
+// 	var errStr *string
+
+// 	token, err := jwt.Parse(req.Body.Token, func(t *jwt.Token) (interface{}, error) {
+// 		if _, ok := t.Method.(*jwt.SigningMethodHMAC); !ok {
+// 			return nil, fmt.Errorf("unexpected signing method")
+// 		}
+// 		return refreshSecret, nil
+// 	})
+
+// 	if err != nil {
+// 		e := err.Error()
+// 		errStr = &e
+// 		return auth.PostAuthVerifyToken200JSONResponse{
+// 			Valid:  &valid,
+// 			UserId: userID,
+// 			Error:  errStr,
+// 		}, nil
+// 	}
+
+// 	if claims, ok := token.Claims.(jwt.MapClaims); ok && token.Valid {
+// 		if uid, ok := claims["user_id"].(string); ok {
+// 			// Refresh token is valid, generate new tokens
+// 			newAccessToken, newRefreshToken, _ := generateTokens(uid)
+// 			valid = true
+// 			userID = &uid
+// 			return auth.PostAuthVerifyToken200JSONResponse{
+// 				Valid:  &valid,
+// 				UserId: userID,
+// 				Error:  nil,
+// 				Token:  &newAccessToken, // return new access token
+// 				// optionally return newRefreshToken as well
+// 			}, nil
+// 		} else {
+// 			e := "user_id not found in refresh token"
+// 			errStr = &e
+// 		}
+// 	} else {
+// 		e := "invalid refresh token claims"
+// 		errStr = &e
+// 	}
+
+// 	return auth.PostAuthVerifyToken200JSONResponse{
+// 		Valid:  &valid,
+// 		UserId: userID,
+// 		Error:  errStr,
+// 	}, nil
+// }

modules/auth/helpers.go

@@ -0,0 +1,33 @@
+package main
+
+import (
+	"fmt"
+	"reflect"
+)
+
+func setField(obj interface{}, name string, value interface{}) error {
+	v := reflect.ValueOf(obj)
+
+	if v.Kind() != reflect.Ptr || v.Elem().Kind() != reflect.Struct {
+		return fmt.Errorf("expected pointer to a struct")
+	}
+
+	v = v.Elem()
+	field := v.FieldByName(name)
+
+	if !field.IsValid() {
+		return fmt.Errorf("no such field: %s", name)
+	}
+	if !field.CanSet() {
+		return fmt.Errorf("cannot set field: %s", name)
+	}
+
+	val := reflect.ValueOf(value)
+
+	if field.Type() != val.Type() {
+		return fmt.Errorf("provided value type (%s) doesn't match field type (%s)", val.Type(), field.Type())
+	}
+
+	field.Set(val)
+	return nil
+}

modules/auth/main.go

@@ -0,0 +1,101 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"reflect"
+	"time"
+
+	auth "nyanimedb/auth"
+	handlers "nyanimedb/modules/auth/handlers"
+	sqlc "nyanimedb/sql"
+
+	"github.com/gin-contrib/cors"
+	"github.com/gin-gonic/gin"
+	"github.com/jackc/pgx/v5/pgxpool"
+	"github.com/pelletier/go-toml/v2"
+	log "github.com/sirupsen/logrus"
+)
+
+var AppConfig Config
+
+func main() {
+	if len(os.Args) != 2 {
+		AppConfig.Mode = "env"
+	} else {
+		AppConfig.Mode = "argv"
+	}
+
+	err := InitConfig()
+	if err != nil {
+		log.Fatalf("Failed to init config: %v\n", err)
+	}
+
+	r := gin.Default()
+
+	pool, err := pgxpool.New(context.Background(), os.Getenv("DATABASE_URL"))
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Unable to connect to database: %v\n", err)
+		os.Exit(1)
+	}
+
+	var queries *sqlc.Queries = sqlc.New(pool)
+
+	server := handlers.NewServer(queries, AppConfig.JwtPrivateKey)
+
+	log.Info("allow origins:", AppConfig.ServiceAddress)
+	r.Use(cors.New(cors.Config{
+		AllowOrigins:     []string{"*"},
+		AllowMethods:     []string{"GET", "POST", "PUT", "DELETE"},
+		AllowHeaders:     []string{"Origin", "Content-Type", "Accept"},
+		ExposeHeaders:    []string{"Content-Length"},
+		AllowCredentials: true,
+		MaxAge:           12 * time.Hour,
+	}))
+
+	auth.RegisterHandlers(r, auth.NewStrictHandler(
+		server,
+		[]auth.StrictMiddlewareFunc{},
+	))
+
+	r.Run(":8082")
+}
+
+func InitConfig() error {
+	if AppConfig.Mode == "argv" {
+		content, err := os.ReadFile(os.Args[1])
+		if err != nil {
+			return err
+		}
+
+		toml.Unmarshal(content, &AppConfig)
+
+		fmt.Printf("%+v\n", AppConfig)
+
+		return nil
+	} else if AppConfig.Mode == "env" {
+		f := reflect.ValueOf(AppConfig)
+
+		for i := 0; i < f.NumField(); i++ {
+			field := f.Type().Field(i)
+			tag := field.Tag
+			env_var := tag.Get("env")
+			fmt.Printf("Field: %v.\nEnvironment variable: %v.\n", field.Name, env_var)
+			if env_var != "" {
+				env_value, exists := os.LookupEnv(env_var)
+				if !exists {
+					return fmt.Errorf("there is no env variable %s", env_var)
+				}
+				err := setField(&AppConfig, field.Name, env_value)
+				if err != nil {
+					return fmt.Errorf("failed to set config field %s: %v", field.Name, err)
+				}
+			}
+		}
+
+		return nil
+	} else {
+		return fmt.Errorf("incorrect config mode")
+	}
+}

modules/auth/queries.sql

@@ -0,0 +1,11 @@
+-- name: GetUserByNickname :one
+SELECT *
+FROM users
+WHERE nickname = sqlc.arg('nickname');
+
+-- name: CreateNewUser :one
+INSERT 
+INTO users (passhash, nickname) 
+VALUES (sqlc.arg(passhash), sqlc.arg(nickname))
+RETURNING id;
+

modules/auth/types.go

@@ -0,0 +1,9 @@
+package main
+
+type Config struct {
+	Mode           string
+	ServiceAddress string `toml:"ServiceAddress" env:"SERVICE_ADDRESS"`
+	DdUrl          string `toml:"DbUrl" env:"DATABASE_URL"`
+	JwtPrivateKey  string `toml:"JwtPrivateKey" env:"JWT_PRIVATE_KEY"`
+	LogLevel       string `toml:"LogLevel" env:"LOG_LEVEL"`
+}

modules/backend/handlers/common.go

@@ -1,19 +1,165 @@
 package handlers
 
 import (
+	"encoding/json"
+	"fmt"
+	oapi "nyanimedb/api"
+	"nyanimedb/modules/backend/rmq"
 	sqlc "nyanimedb/sql"
 	"strconv"
 )
 
+type Handler struct {
+	publisher *rmq.Publisher
+}
+
+func New(publisher *rmq.Publisher) *Handler {
+	return &Handler{publisher: publisher}
+}
+
 type Server struct {
-	db *sqlc.Queries
+	db        *sqlc.Queries
+	publisher *rmq.Publisher
+	RPCclient *rmq.RPCClient
 }
 
-func NewServer(db *sqlc.Queries) Server {
-	return Server{db: db}
+func NewServer(db *sqlc.Queries, publisher *rmq.Publisher, rpcclient *rmq.RPCClient) *Server {
+	return &Server{
+		db:        db,
+		publisher: publisher,
+		RPCclient: rpcclient,
+	}
 }
 
-func parseInt64(s string) (int32, error) {
+func sql2StorageType(s *sqlc.StorageTypeT) (*oapi.StorageType, error) {
+	if s == nil {
+		return nil, nil
+	}
+	var t oapi.StorageType
+	switch *s {
+	case sqlc.StorageTypeTLocal:
+		t = oapi.Local
+	case sqlc.StorageTypeTS3:
+		t = oapi.S3
+	default:
+		return nil, fmt.Errorf("unexpected storage type: %s", *s)
+	}
+	return &t, nil
+}
+
+func (s Server) mapTitle(title sqlc.GetTitleByIDRow) (oapi.Title, error) {
+
+	oapi_title := oapi.Title{
+		EpisodesAired: title.EpisodesAired,
+		EpisodesAll:   title.EpisodesAll,
+		// EpisodesLen:   &episodes_lens,
+		Id: title.ID,
+		// Poster:        &oapi_image,
+		Rating:      title.Rating,
+		RatingCount: title.RatingCount,
+		// ReleaseSeason: &release_season,
+		ReleaseYear: title.ReleaseYear,
+		// Studio:        &oapi_studio,
+		// Tags:          oapi_tag_names,
+		// TitleNames:    title_names,
+		// TitleStatus:   oapi_status,
+		// AdditionalProperties:
+	}
+
+	title_names := make(map[string][]string, 0)
+	err := json.Unmarshal(title.TitleNames, &title_names)
+	if err != nil {
+		return oapi.Title{}, fmt.Errorf("unmarshal TitleNames: %v", err)
+	}
+	oapi_title.TitleNames = title_names
+
+	if len(title.EpisodesLen) > 0 {
+		episodes_lens := make(map[string]float64, 0)
+		err = json.Unmarshal(title.EpisodesLen, &episodes_lens)
+		if err != nil {
+			return oapi.Title{}, fmt.Errorf("unmarshal EpisodesLen: %v", err)
+		}
+		oapi_title.EpisodesLen = &episodes_lens
+	}
+
+	oapi_tag_names := make(oapi.Tags, 0)
+	err = json.Unmarshal(title.TagNames, &oapi_tag_names)
+	if err != nil {
+		return oapi.Title{}, fmt.Errorf("unmarshalling title_tag: %v", err)
+	}
+	oapi_title.Tags = oapi_tag_names
+
+	var oapi_studio oapi.Studio
+	if title.StudioName != nil {
+		oapi_studio.Name = *title.StudioName
+	}
+	if title.StudioID != 0 {
+		oapi_studio.Id = title.StudioID
+		oapi_studio.Description = title.StudioDesc
+		if title.StudioIllustID != nil {
+			oapi_studio.Poster = &oapi.Image{}
+			oapi_studio.Poster.Id = title.StudioIllustID
+			oapi_studio.Poster.ImagePath = title.StudioImagePath
+
+			s, err := sql2StorageType(title.StudioStorageType)
+			if err != nil {
+				return oapi.Title{}, fmt.Errorf("mapTitle, studio storage type: %v", err)
+			}
+			oapi_studio.Poster.StorageType = s
+
+		}
+	}
+	oapi_title.Studio = &oapi_studio
+
+	var oapi_image oapi.Image
+
+	if title.PosterID != nil {
+		oapi_image.Id = title.PosterID
+		oapi_image.ImagePath = title.TitleImagePath
+		s, err := sql2StorageType(title.TitleStorageType)
+		if err != nil {
+			return oapi.Title{}, fmt.Errorf("mapTitle, title starage type: %v", err)
+		}
+		oapi_image.StorageType = s
+	}
+	oapi_title.Poster = &oapi_image
+
+	var release_season oapi.ReleaseSeason
+	if title.ReleaseSeason != nil {
+		release_season = oapi.ReleaseSeason(*title.ReleaseSeason)
+	}
+	oapi_title.ReleaseSeason = &release_season
+
+	oapi_status, err := TitleStatus2oapi(&title.TitleStatus)
+	if err != nil {
+		return oapi.Title{}, fmt.Errorf("TitleStatus2oapi: %v", err)
+	}
+	oapi_title.TitleStatus = oapi_status
+
+	return oapi_title, nil
+}
+
+func parseInt64(s string) (int64, error) {
 	i, err := strconv.ParseInt(s, 10, 64)
-	return int32(i), err
+	return i, err
+}
+
+func TitleStatus2Sqlc(s *[]oapi.TitleStatus) ([]sqlc.TitleStatusT, error) {
+	var sqlc_status []sqlc.TitleStatusT
+	if s == nil {
+		return nil, nil
+	}
+	for _, t := range *s {
+		switch t {
+		case oapi.TitleStatusFinished:
+			sqlc_status = append(sqlc_status, sqlc.TitleStatusTFinished)
+		case oapi.TitleStatusOngoing:
+			sqlc_status = append(sqlc_status, sqlc.TitleStatusTOngoing)
+		case oapi.TitleStatusPlanned:
+			sqlc_status = append(sqlc_status, sqlc.TitleStatusTPlanned)
+		default:
+			return nil, fmt.Errorf("unexpected tittle status: %s", t)
+		}
+	}
+	return sqlc_status, nil
 }

modules/backend/handlers/cursor.go

@@ -0,0 +1,156 @@
+package handlers
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"strconv"
+)
+
+// ParseCursorInto parses an opaque base64 cursor and injects values into target struct.
+//
+// Supported sort types:
+//   - "id"     → sets CursorID (must be *int64)
+//   - "year"   → sets CursorID (*int64) + CursorYear (*int32)
+//   - "rating" → sets CursorID (*int64) + CursorRating (*float64)
+//
+// Target struct may have any subset of these fields (e.g. only CursorID).
+// Unknown fields are ignored. Missing fields → values are dropped (safe).
+//
+// Returns error if cursor is invalid or inconsistent with sort_by.
+func ParseCursorInto(sortBy, cursorStr string, target any) error {
+	if cursorStr == "" {
+		return nil // no cursor → nothing to do
+	}
+
+	// 1. Decode cursor
+	payload, err := decodeCursor(cursorStr)
+	if err != nil {
+		return err
+	}
+
+	// 2. Extract ID (required for all types)
+	id, err := extractInt64(payload, "id")
+	if err != nil {
+		return fmt.Errorf("cursor: %v", err)
+	}
+
+	// 3. Get reflect value of target (must be ptr to struct)
+	v := reflect.ValueOf(target)
+	if v.Kind() != reflect.Pointer || v.IsNil() {
+		return fmt.Errorf("target must be non-nil pointer to struct")
+	}
+	v = v.Elem()
+	if v.Kind() != reflect.Struct {
+		return fmt.Errorf("target must be pointer to struct")
+	}
+
+	// 4. Helper: set field if exists and compatible
+	setField := func(fieldName string, value any) {
+		f := v.FieldByName(fieldName)
+		if !f.IsValid() || !f.CanSet() {
+			return // field not found or unexported
+		}
+		ft := f.Type()
+		vv := reflect.ValueOf(value)
+
+		// Case: field is *T, value is T → wrap in pointer
+		if ft.Kind() == reflect.Pointer {
+			elemType := ft.Elem()
+			if vv.Type().AssignableTo(elemType) {
+				ptr := reflect.New(elemType)
+				ptr.Elem().Set(vv)
+				f.Set(ptr)
+			}
+			// nil → leave as zero (nil pointer)
+		} else if vv.Type().AssignableTo(ft) {
+			f.Set(vv)
+		}
+		// else: type mismatch → silently skip (safe)
+	}
+
+	// 5. Dispatch by sort type
+	switch sortBy {
+	case "id":
+		setField("CursorID", id)
+
+	case "year":
+		setField("CursorID", id)
+		param, err := extractString(payload, "param")
+		if err != nil {
+			return fmt.Errorf("cursor year: %w", err)
+		}
+		year, err := strconv.Atoi(param)
+		if err != nil {
+			return fmt.Errorf("cursor year: param must be integer, got %q", param)
+		}
+		setField("CursorYear", int32(year)) // or int, depending on your schema
+
+	case "rating":
+		setField("CursorID", id)
+		param, err := extractString(payload, "param")
+		if err != nil {
+			return fmt.Errorf("cursor rating: %w", err)
+		}
+		rating, err := strconv.ParseFloat(param, 64)
+		if err != nil {
+			return fmt.Errorf("cursor rating: param must be float, got %q", param)
+		}
+		setField("CursorRating", rating)
+
+	default:
+		return fmt.Errorf("unsupported sort_by: %q", sortBy)
+	}
+
+	return nil
+}
+
+// --- helpers ---
+func decodeCursor(cursorStr string) (map[string]any, error) {
+	data, err := base64.RawURLEncoding.DecodeString(cursorStr)
+	if err != nil {
+		data, err = base64.StdEncoding.DecodeString(cursorStr)
+		if err != nil {
+			return nil, fmt.Errorf("invalid base64 cursor")
+		}
+	}
+	var m map[string]any
+	if err := json.Unmarshal(data, &m); err != nil {
+		return nil, fmt.Errorf("invalid cursor JSON: %w", err)
+	}
+	return m, nil
+}
+
+func extractInt64(m map[string]any, key string) (int64, error) {
+	v, ok := m[key]
+	if !ok {
+		return 0, fmt.Errorf("missing %q", key)
+	}
+	switch x := v.(type) {
+	case float64:
+		if x == float64(int64(x)) {
+			return int64(x), nil
+		}
+	case string:
+		i, err := strconv.ParseInt(x, 10, 64)
+		if err == nil {
+			return i, nil
+		}
+	case int64, int, int32:
+		return reflect.ValueOf(x).Int(), nil
+	}
+	return 0, fmt.Errorf("%q must be integer", key)
+}
+
+func extractString(m map[string]any, key string) (string, error) {
+	v, ok := m[key]
+	if !ok {
+		return "", fmt.Errorf("missing %q", key)
+	}
+	s, ok := v.(string)
+	if !ok {
+		return "", fmt.Errorf("%q must be string", key)
+	}
+	return s, nil
+}

modules/backend/handlers/titles.go

@@ -5,7 +5,10 @@ import (
 	"encoding/json"
 	"fmt"
 	oapi "nyanimedb/api"
+	"nyanimedb/modules/backend/rmq"
 	sqlc "nyanimedb/sql"
+	"strconv"
+	"time"
 
 	"github.com/jackc/pgx/v5"
 	log "github.com/sirupsen/logrus"
@@ -19,18 +22,18 @@ func Word2Sqlc(s *string) *string {
 	return s
 }
 
-func TitleStatus2Sqlc(s *oapi.TitleStatus) (*sqlc.TitleStatusT, error) {
+func TitleStatus2oapi(s *sqlc.TitleStatusT) (*oapi.TitleStatus, error) {
 	if s == nil {
 		return nil, nil
 	}
-	var t sqlc.TitleStatusT
+	var t oapi.TitleStatus
 	switch *s {
-	case oapi.Finished:
-		t = sqlc.TitleStatusTFinished
-	case oapi.Ongoing:
-		t = sqlc.TitleStatusTOngoing
-	case oapi.Planned:
-		t = sqlc.TitleStatusTPlanned
+	case sqlc.TitleStatusTFinished:
+		t = oapi.TitleStatusFinished
+	case sqlc.TitleStatusTOngoing:
+		t = oapi.TitleStatusOngoing
+	case sqlc.TitleStatusTPlanned:
+		t = oapi.TitleStatusPlanned
 	default:
 		return nil, fmt.Errorf("unexpected tittle status: %s", *s)
 	}
@@ -80,178 +83,223 @@ func (s Server) GetTagsByTitleId(ctx context.Context, id int64) (oapi.Tags, erro
 	return oapi_tag_names, nil
 }
 
-func (s Server) GetImage(ctx context.Context, id int64) (*oapi.Image, error) {
+// func (s Server) GetImage(ctx context.Context, id int64) (*oapi.Image, error) {
 
-	var oapi_image oapi.Image
+// 	var oapi_image oapi.Image
 
-	sqlc_image, err := s.db.GetImageByID(ctx, id)
-	if err != nil {
-		if err == pgx.ErrNoRows {
-			return nil, nil
-		}
-		return &oapi_image, fmt.Errorf("query GetImageByID: %v", err)
-	}
+// 	sqlc_image, err := s.db.GetImageByID(ctx, id)
+// 	if err != nil {
+// 		if err == pgx.ErrNoRows {
+// 			return nil, nil //todo: error reference in db
+// 		}
+// 		return &oapi_image, fmt.Errorf("query GetImageByID: %v", err)
+// 	}
 
-	//can cast and dont use brain cause all this fields  required in image table
-	oapi_image.Id = &sqlc_image.ID
-	oapi_image.ImagePath = &sqlc_image.ImagePath
-	storageTypeStr := string(sqlc_image.StorageType)
-	oapi_image.StorageType = &storageTypeStr
+// 	//can cast and dont use brain cause all this fields  required in image table
+// 	oapi_image.Id = &sqlc_image.ID
+// 	oapi_image.ImagePath = &sqlc_image.ImagePath
+// 	storageTypeStr := string(sqlc_image.StorageType)
+// 	oapi_image.StorageType = string(storageTypeStr)
 
-	return &oapi_image, nil
-}
+// 	return &oapi_image, nil
+// }
 
-func (s Server) GetStudio(ctx context.Context, id int64) (*oapi.Studio, error) {
+// func (s Server) GetStudio(ctx context.Context, id int64) (*oapi.Studio, error) {
 
-	var oapi_studio oapi.Studio
+// 	var oapi_studio oapi.Studio
 
-	sqlc_studio, err := s.db.GetStudioByID(ctx, id)
-	if err != nil {
-		if err == pgx.ErrNoRows {
-			return nil, nil
-		}
-		return &oapi_studio, fmt.Errorf("query GetStudioByID: %v", err)
-	}
+// 	sqlc_studio, err := s.db.GetStudioByID(ctx, id)
+// 	if err != nil {
+// 		if err == pgx.ErrNoRows {
+// 			return nil, nil
+// 		}
+// 		return &oapi_studio, fmt.Errorf("query GetStudioByID: %v", err)
+// 	}
 
-	oapi_studio.Id = sqlc_studio.ID
-	oapi_studio.Name = sqlc_studio.StudioName
-	oapi_studio.Description = sqlc_studio.StudioDesc
+// 	oapi_studio.Id = sqlc_studio.ID
+// 	oapi_studio.Name = sqlc_studio.StudioName
+// 	oapi_studio.Description = sqlc_studio.StudioDesc
 
-	oapi_illust, err := s.GetImage(ctx, *sqlc_studio.IllustID)
-	if err != nil {
-		return &oapi_studio, fmt.Errorf("GetImage: %v", err)
-	}
-	if oapi_illust != nil {
-		oapi_studio.Poster = oapi_illust
-	}
+// 	if sqlc_studio.IllustID == nil {
+// 		return &oapi_studio, nil
+// 	}
+// 	oapi_illust, err := s.GetImage(ctx, *sqlc_studio.IllustID)
+// 	if err != nil {
+// 		return &oapi_studio, fmt.Errorf("GetImage: %v", err)
+// 	}
+// 	if oapi_illust != nil {
+// 		oapi_studio.Poster = oapi_illust
+// 	}
 
-	return &oapi_studio, nil
-}
+// 	return &oapi_studio, nil
+// }
 
-func (s Server) mapTitle(ctx context.Context, title sqlc.Title) (oapi.Title, error) {
-
-	var oapi_title oapi.Title
-
-	title_names := make(map[string][]string, 1)
-	err := json.Unmarshal(title.TitleNames, &title_names)
-	if err != nil {
-		return oapi_title, fmt.Errorf("unmarshal TitleNames: %v", err)
-	}
-
-	episodes_lens := make(map[string]float64, 1)
-	err = json.Unmarshal(title.EpisodesLen, &episodes_lens)
-	if err != nil {
-		return oapi_title, fmt.Errorf("unmarshal EpisodesLen: %v", err)
-	}
-
-	oapi_tag_names, err := s.GetTagsByTitleId(ctx, title.ID)
-	if err != nil {
-		return oapi_title, fmt.Errorf("GetTagsByTitleId: %v", err)
-	}
-	if oapi_tag_names != nil {
-		oapi_title.Tags = oapi_tag_names
-	}
-
-	oapi_image, err := s.GetImage(ctx, *title.PosterID)
-	if err != nil {
-		return oapi_title, fmt.Errorf("GetImage: %v", err)
-	}
-	if oapi_image != nil {
-		oapi_title.Poster = oapi_image
-	}
-
-	oapi_studio, err := s.GetStudio(ctx, title.StudioID)
-	if err != nil {
-		return oapi_title, fmt.Errorf("GetStudio: %v", err)
-	}
-	if oapi_studio != nil {
-		oapi_title.Studio = oapi_studio
-	}
-
-	if title.ReleaseSeason != nil {
-		rs := oapi.ReleaseSeason(*title.ReleaseSeason)
-		oapi_title.ReleaseSeason = &rs
-	} else {
-		oapi_title.ReleaseSeason = nil
-	}
-
-	ts := oapi.TitleStatus(title.TitleStatus)
-	oapi_title.TitleStatus = &ts
-
-	oapi_title.Id = title.ID
-	oapi_title.Rating = title.Rating
-	oapi_title.RatingCount = title.RatingCount
-	oapi_title.ReleaseYear = title.ReleaseYear
-	oapi_title.TitleNames = title_names
-	oapi_title.EpisodesAired = title.EpisodesAired
-	oapi_title.EpisodesAll = title.EpisodesAll
-	oapi_title.EpisodesLen = &episodes_lens
-
-	return oapi_title, nil
-}
-
-func (s Server) GetTitleTitleId(ctx context.Context, request oapi.GetTitleTitleIdRequestObject) (oapi.GetTitleTitleIdResponseObject, error) {
+func (s Server) GetTitle(ctx context.Context, request oapi.GetTitleRequestObject) (oapi.GetTitleResponseObject, error) {
 	var oapi_title oapi.Title
 
 	sqlc_title, err := s.db.GetTitleByID(ctx, request.TitleId)
 	if err != nil {
 		if err == pgx.ErrNoRows {
-			return oapi.GetTitleTitleId204Response{}, nil
+			return oapi.GetTitle204Response{}, nil
 		}
 		log.Errorf("%v", err)
-		return oapi.GetTitleTitleId500Response{}, nil
+		return oapi.GetTitle500Response{}, nil
 	}
 
-	oapi_title, err = s.mapTitle(ctx, sqlc_title)
-	if err != nil {
-		log.Errorf("%v", err)
-		return oapi.GetTitleTitleId500Response{}, nil
-	}
-
-	return oapi.GetTitleTitleId200JSONResponse(oapi_title), nil
-}
-
-func (s Server) GetTitle(ctx context.Context, request oapi.GetTitleRequestObject) (oapi.GetTitleResponseObject, error) {
-	opai_titles := make([]oapi.Title, 1)
-
-	word := Word2Sqlc(request.Params.Word)
-	status, err := TitleStatus2Sqlc(request.Params.Status)
-	if err != nil {
-		log.Errorf("%v", err)
-		return oapi.GetTitle400Response{}, err
-	}
-	season, err := ReleaseSeason2sqlc(request.Params.ReleaseSeason)
-	if err != nil {
-		log.Errorf("%v", err)
-		return oapi.GetTitle400Response{}, err
-	}
-	// param = nil means it will not be used
-	titles, err := s.db.SearchTitles(ctx, sqlc.SearchTitlesParams{
-		Word:          word,
-		Status:        status,
-		Rating:        request.Params.Rating,
-		ReleaseYear:   request.Params.ReleaseYear,
-		ReleaseSeason: season,
-		Offset:        request.Params.Offset,
-		Limit:         request.Params.Limit,
-	})
+	oapi_title, err = s.mapTitle(sqlc_title)
 	if err != nil {
 		log.Errorf("%v", err)
 		return oapi.GetTitle500Response{}, nil
 	}
-	if len(titles) == 0 {
-		return oapi.GetTitle204Response{}, nil
+
+	return oapi.GetTitle200JSONResponse(oapi_title), nil
+}
+
+func (s Server) GetTitles(ctx context.Context, request oapi.GetTitlesRequestObject) (oapi.GetTitlesResponseObject, error) {
+
+	opai_titles := make([]oapi.Title, 0)
+	mqreq := rmq.RabbitRequest{
+		Timestamp: time.Now(),
 	}
 
+	word := Word2Sqlc(request.Params.Word)
+	if word != nil {
+		mqreq.Name = *word
+	}
+
+	season, err := ReleaseSeason2sqlc(request.Params.ReleaseSeason)
+	if err != nil {
+		log.Errorf("%v", err)
+		return oapi.GetTitles400Response{}, err
+	}
+	if season != nil {
+		mqreq.Season = *request.Params.ReleaseSeason
+	}
+
+	title_statuses, err := TitleStatus2Sqlc(request.Params.Status)
+	if err != nil {
+		log.Errorf("%v", err)
+		return oapi.GetTitles400Response{}, err
+	}
+	if title_statuses != nil {
+		mqreq.Statuses = *request.Params.Status
+	}
+
+	if request.Params.ExtSearch != nil && *request.Params.ExtSearch {
+
+		// Структура для ответа (должна совпадать с тем, что шлёт микросервис)
+		var reply struct {
+			Status  string `json:"status"`
+			Result  string `json:"result"`
+			Preview string `json:"preview_url"`
+		}
+
+		// Делаем RPC-вызов — и ЖДЁМ ответа
+		err := s.RPCclient.Call(
+			ctx,
+			"svc.media.process.requests", // ← очередь микросервиса
+			mqreq,
+			&reply,
+		)
+		if err != nil {
+			log.Errorf("RabitMQ: %v", err)
+			// return oapi.GetTitles500Response{}, err
+		}
+		// // Возвращаем результат
+		// return oapi.ProcessMedia200JSONResponse{
+		// 	Status:  reply.Status,
+		// 	Result:  reply.Result,
+		// 	Preview: reply.Preview,
+		// }, nil
+	}
+
+	params := sqlc.SearchTitlesParams{
+		Word:          word,
+		TitleStatuses: title_statuses,
+		Rating:        request.Params.Rating,
+		ReleaseYear:   request.Params.ReleaseYear,
+		ReleaseSeason: season,
+		Forward:       true, // default
+		SortBy:        "id", // default
+		Limit:         request.Params.Limit,
+	}
+
+	if request.Params.SortForward != nil {
+		params.Forward = *request.Params.SortForward
+	}
+	if request.Params.Sort != nil {
+		params.SortBy = string(*request.Params.Sort)
+		if request.Params.Cursor != nil {
+			// here we set CursorYear CursorID CursorRating fields
+			err := ParseCursorInto(string(*request.Params.Sort), string(*request.Params.Cursor), &params)
+			if err != nil {
+				log.Errorf("%v", err)
+				return oapi.GetTitles400Response{}, nil
+			}
+		}
+	}
+	// param = nil means it will not be used
+	titles, err := s.db.SearchTitles(ctx, params)
+	if err != nil {
+		log.Errorf("%v", err)
+		return oapi.GetTitles500Response{}, nil
+	}
+	if len(titles) == 0 {
+		return oapi.GetTitles204Response{}, nil
+	}
+
+	var new_cursor oapi.CursorObj
+
 	for _, title := range titles {
 
-		t, err := s.mapTitle(ctx, title)
+		_title := sqlc.GetTitleByIDRow{
+			ID: title.ID,
+			// StudioID:          title.StudioID,
+			PosterID:      title.PosterID,
+			TitleStatus:   title.TitleStatus,
+			Rating:        title.Rating,
+			RatingCount:   title.RatingCount,
+			ReleaseYear:   title.ReleaseYear,
+			ReleaseSeason: title.ReleaseSeason,
+			Season:        title.Season,
+			EpisodesAired: title.EpisodesAired,
+			EpisodesAll:   title.EpisodesAll,
+			// EpisodesLen:       title.EpisodesLen,
+			TitleStorageType: title.TitleStorageType,
+			TitleImagePath:   title.TitleImagePath,
+			TitleNames:       title.TitleNames,
+			TagNames:         title.TagNames,
+			StudioName:       title.StudioName,
+			// StudioIllustID:    title.StudioIllustID,
+			// StudioDesc:        title.StudioDesc,
+			// StudioStorageType: title.StudioStorageType,
+			// StudioImagePath:   title.StudioImagePath,
+		}
+
+		// if title.TitleStorageType != nil {
+		// 	s := *title.TitleStorageType
+		// 	_title.TitleStorageType = string(s)
+		// }
+
+		t, err := s.mapTitle(_title)
 		if err != nil {
 			log.Errorf("%v", err)
-			return oapi.GetTitle500Response{}, nil
+			return oapi.GetTitles500Response{}, nil
 		}
 		opai_titles = append(opai_titles, t)
+
+		new_cursor.Id = t.Id
+		if request.Params.Sort != nil {
+			switch string(*request.Params.Sort) {
+			case "year":
+				tmp := fmt.Sprint(*t.ReleaseYear)
+				new_cursor.Param = &tmp
+			case "rating":
+				tmp := strconv.FormatFloat(*t.Rating, 'f', -1, 64)
+				new_cursor.Param = &tmp
+			}
+		}
 	}
 
-	return oapi.GetTitle200JSONResponse(opai_titles), nil
+	return oapi.GetTitles200JSONResponse{Cursor: new_cursor, Data: opai_titles}, nil
 }

modules/backend/handlers/users.go

@@ -2,49 +2,486 @@ package handlers
 
 import (
 	"context"
+	"errors"
+	"fmt"
 	oapi "nyanimedb/api"
 	sqlc "nyanimedb/sql"
+	"strconv"
+	"time"
 
 	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgconn"
+	"github.com/jackc/pgx/v5/pgtype"
 	"github.com/oapi-codegen/runtime/types"
+	log "github.com/sirupsen/logrus"
 )
 
-// type Server struct {
-// 	db *sqlc.Queries
-// }
+const (
+	pgErrDuplicateKey = "23505"
+)
 
-// func NewServer(db *sqlc.Queries) Server {
-// 	return Server{db: db}
-// }
-
-// func parseInt64(s string) (int32, error) {
-// 	i, err := strconv.ParseInt(s, 10, 64)
-// 	return int32(i), err
-// }
-
-func mapUser(u sqlc.GetUserByIDRow) oapi.User {
+func mapUser(u sqlc.GetUserByIDRow) (oapi.User, error) {
+	i := oapi.Image{
+		Id:        u.AvatarID,
+		ImagePath: u.ImagePath,
+	}
+	s, err := sql2StorageType(u.StorageType)
+	if err != nil {
+		return oapi.User{}, fmt.Errorf("mapUser, storage type: %v", err)
+	}
+	i.StorageType = s
 	return oapi.User{
-		AvatarId:     u.AvatarID,
+		Image:        &i,
 		CreationDate: &u.CreationDate,
 		DispName:     u.DispName,
 		Id:           &u.ID,
-		Mail:         (*types.Email)(u.Mail),
+		Mail:         StringToEmail(u.Mail),
 		Nickname:     u.Nickname,
 		UserDesc:     u.UserDesc,
-	}
+	}, nil
 }
 
-func (s Server) GetUsersUserId(ctx context.Context, req oapi.GetUsersUserIdRequestObject) (oapi.GetUsersUserIdResponseObject, error) {
+func (s Server) GetUsersId(ctx context.Context, req oapi.GetUsersIdRequestObject) (oapi.GetUsersIdResponseObject, error) {
 	userID, err := parseInt64(req.UserId)
 	if err != nil {
-		return oapi.GetUsersUserId404Response{}, nil
+		return oapi.GetUsersId404Response{}, nil
 	}
-	user, err := s.db.GetUserByID(context.TODO(), int64(userID))
+	_user, err := s.db.GetUserByID(context.TODO(), userID)
 	if err != nil {
 		if err == pgx.ErrNoRows {
-			return oapi.GetUsersUserId404Response{}, nil
+			return oapi.GetUsersId404Response{}, nil
 		}
 		return nil, err
 	}
-	return oapi.GetUsersUserId200JSONResponse(mapUser(user)), nil
+	user, err := mapUser(_user)
+	if err != nil {
+		log.Errorf("%v", err)
+		return oapi.GetUsersId500Response{}, err
+	}
+	return oapi.GetUsersId200JSONResponse(user), nil
+}
+
+func sqlDate2oapi(p_date pgtype.Timestamptz) *time.Time {
+	if p_date.Valid {
+		t := p_date.Time
+		return &t
+	}
+	return nil
+}
+
+// func UserTitleStatus2Sqlc(s *[]oapi.UserTitleStatus) (*SqlcUserStatus, error) {
+// 	var sqlc_status SqlcUserStatus
+// 	if s == nil {
+// 		return &sqlc_status, nil
+// 	}
+// 	for _, t := range *s {
+// 		switch t {
+// 		case oapi.UserTitleStatusFinished:
+// 			sqlc_status.finished = "finished"
+// 		case oapi.UserTitleStatusDropped:
+// 			sqlc_status.dropped = "dropped"
+// 		case oapi.UserTitleStatusPlanned:
+// 			sqlc_status.planned = "planned"
+// 		case oapi.UserTitleStatusInProgress:
+// 			sqlc_status.in_progress = "in-progress"
+// 		default:
+// 			return nil, fmt.Errorf("unexpected tittle status: %s", t)
+// 		}
+// 	}
+// 	return &sqlc_status, nil
+// }
+
+func sql2usertitlestatus(s sqlc.UsertitleStatusT) (oapi.UserTitleStatus, error) {
+	var status oapi.UserTitleStatus
+
+	switch s {
+	case sqlc.UsertitleStatusTFinished:
+		status = oapi.UserTitleStatusFinished
+	case sqlc.UsertitleStatusTDropped:
+		status = oapi.UserTitleStatusDropped
+	case sqlc.UsertitleStatusTPlanned:
+		status = oapi.UserTitleStatusPlanned
+	case sqlc.UsertitleStatusTInProgress:
+		status = oapi.UserTitleStatusInProgress
+	default:
+		return status, fmt.Errorf("unexpected tittle status: %s", s)
+	}
+
+	return status, nil
+}
+
+func UserTitleStatus2Sqlc(s *[]oapi.UserTitleStatus) ([]sqlc.UsertitleStatusT, error) {
+	var sqlc_status []sqlc.UsertitleStatusT
+	if s == nil {
+		return nil, nil
+	}
+	for _, t := range *s {
+		switch t {
+		case oapi.UserTitleStatusFinished:
+			sqlc_status = append(sqlc_status, sqlc.UsertitleStatusTFinished)
+		case oapi.UserTitleStatusInProgress:
+			sqlc_status = append(sqlc_status, sqlc.UsertitleStatusTInProgress)
+		case oapi.UserTitleStatusDropped:
+			sqlc_status = append(sqlc_status, sqlc.UsertitleStatusTDropped)
+		case oapi.UserTitleStatusPlanned:
+			sqlc_status = append(sqlc_status, sqlc.UsertitleStatusTPlanned)
+		default:
+			return nil, fmt.Errorf("unexpected tittle status: %s", t)
+		}
+	}
+	return sqlc_status, nil
+}
+
+func UserTitleStatus2Sqlc1(s *oapi.UserTitleStatus) (*sqlc.UsertitleStatusT, error) {
+	var sqlc_status sqlc.UsertitleStatusT = sqlc.UsertitleStatusTFinished
+	if s == nil {
+		return &sqlc_status, nil
+	}
+
+	switch *s {
+	case oapi.UserTitleStatusFinished:
+		sqlc_status = sqlc.UsertitleStatusTFinished
+	case oapi.UserTitleStatusInProgress:
+		sqlc_status = sqlc.UsertitleStatusTInProgress
+	case oapi.UserTitleStatusDropped:
+		sqlc_status = sqlc.UsertitleStatusTDropped
+	case oapi.UserTitleStatusPlanned:
+		sqlc_status = sqlc.UsertitleStatusTPlanned
+	default:
+		return nil, fmt.Errorf("unexpected tittle status: %s", *s)
+	}
+
+	return &sqlc_status, nil
+}
+
+func (s Server) mapUsertitle(ctx context.Context, t sqlc.SearchUserTitlesRow) (oapi.UserTitle, error) {
+
+	oapi_usertitle := oapi.UserTitle{
+		Ctime:    &t.UserCtime,
+		Rate:     t.UserRate,
+		ReviewId: t.ReviewID,
+		// Status: ,
+		// Title: ,
+		UserId: t.UserID,
+	}
+
+	status, err := sql2usertitlestatus(t.UsertitleStatus)
+	if err != nil {
+		return oapi_usertitle, fmt.Errorf("mapUsertitle: %v", err)
+	}
+	oapi_usertitle.Status = status
+
+	_title := sqlc.GetTitleByIDRow{
+		ID: t.ID,
+		// StudioID:          title.StudioID,
+		PosterID:      t.PosterID,
+		TitleStatus:   t.TitleStatus,
+		Rating:        t.Rating,
+		RatingCount:   t.RatingCount,
+		ReleaseYear:   t.ReleaseYear,
+		ReleaseSeason: t.ReleaseSeason,
+		Season:        t.Season,
+		EpisodesAired: t.EpisodesAired,
+		EpisodesAll:   t.EpisodesAll,
+		// EpisodesLen:       title.EpisodesLen,
+		TitleStorageType: t.TitleStorageType,
+		TitleImagePath:   t.TitleImagePath,
+		StudioName:       t.StudioName,
+		TitleNames:       t.TitleNames,
+		TagNames:         t.TagNames,
+		// StudioIllustID:    title.StudioIllustID,
+		// StudioDesc:        title.StudioDesc,
+		// StudioStorageType: title.StudioStorageType,
+		// StudioImagePath:   title.StudioImagePath,
+	}
+
+	oapi_title, err := s.mapTitle(_title)
+	if err != nil {
+		return oapi_usertitle, fmt.Errorf("mapUsertitle: %v", err)
+	}
+	oapi_usertitle.Title = &oapi_title
+
+	return oapi_usertitle, nil
+}
+
+func (s Server) GetUserTitles(ctx context.Context, request oapi.GetUserTitlesRequestObject) (oapi.GetUserTitlesResponseObject, error) {
+
+	oapi_usertitles := make([]oapi.UserTitle, 0)
+
+	word := Word2Sqlc(request.Params.Word)
+
+	season, err := ReleaseSeason2sqlc(request.Params.ReleaseSeason)
+	if err != nil {
+		log.Errorf("%v", err)
+		return oapi.GetUserTitles400Response{}, err
+	}
+
+	// var statuses_sort []string
+	// if request.Params.Status != nil {
+	// 	for _, s := range *request.Params.Status {
+	// 		ss := string(s) // s type is alias for string
+	// 		statuses_sort = append(statuses_sort, ss)
+	// 	}
+	// }
+
+	watch_status, err := UserTitleStatus2Sqlc(request.Params.WatchStatus)
+	if err != nil {
+		log.Errorf("%v", err)
+		return oapi.GetUserTitles400Response{}, err
+	}
+
+	title_statuses, err := TitleStatus2Sqlc(request.Params.Status)
+	if err != nil {
+		log.Errorf("%v", err)
+		return oapi.GetUserTitles400Response{}, err
+	}
+
+	userID, err := parseInt64(request.UserId)
+	if err != nil {
+		log.Errorf("get user titles: %v", err)
+		return oapi.GetUserTitles404Response{}, err
+	}
+	params := sqlc.SearchUserTitlesParams{
+		UserID:            userID,
+		Word:              word,
+		TitleStatuses:     title_statuses,
+		UsertitleStatuses: watch_status,
+		Rating:            request.Params.Rating,
+		Rate:              request.Params.MyRate,
+		ReleaseYear:       request.Params.ReleaseYear,
+		ReleaseSeason:     season,
+		Forward:           true, // default
+		SortBy:            "id", // default
+		Limit:             request.Params.Limit,
+	}
+
+	if request.Params.SortForward != nil {
+		params.Forward = *request.Params.SortForward
+	}
+	if request.Params.Sort != nil {
+		params.SortBy = string(*request.Params.Sort)
+		if request.Params.Cursor != nil {
+			// here we set CursorYear CursorID CursorRating fields
+			err := ParseCursorInto(string(*request.Params.Sort), string(*request.Params.Cursor), &params)
+			if err != nil {
+				log.Errorf("%v", err)
+				return oapi.GetUserTitles400Response{}, nil
+			}
+		}
+	}
+	// param = nil means it will not be used
+	titles, err := s.db.SearchUserTitles(ctx, params)
+	if err != nil {
+		log.Errorf("%v", err)
+		return oapi.GetUserTitles500Response{}, nil
+	}
+	if len(titles) == 0 {
+		return oapi.GetUserTitles204Response{}, nil
+	}
+
+	var new_cursor oapi.CursorObj
+
+	for _, title := range titles {
+
+		t, err := s.mapUsertitle(ctx, title)
+		if err != nil {
+			log.Errorf("%v", err)
+			return oapi.GetUserTitles500Response{}, nil
+		}
+		oapi_usertitles = append(oapi_usertitles, t)
+
+		new_cursor.Id = t.Title.Id
+		if request.Params.Sort != nil {
+			switch string(*request.Params.Sort) {
+			case "year":
+				tmp := fmt.Sprint(*t.Title.ReleaseYear)
+				new_cursor.Param = &tmp
+			case "rating":
+				tmp := strconv.FormatFloat(*t.Title.Rating, 'f', -1, 64) // падает
+				new_cursor.Param = &tmp
+			}
+		}
+	}
+
+	return oapi.GetUserTitles200JSONResponse{Cursor: new_cursor, Data: oapi_usertitles}, nil
+}
+
+func EmailToStringPtr(e *types.Email) *string {
+	if e == nil {
+		return nil
+	}
+	s := string(*e)
+	return &s
+}
+
+func StringToEmail(e *string) *types.Email {
+	if e == nil {
+		return nil
+	}
+	s := types.Email(*e)
+	return &s
+}
+
+// UpdateUser implements oapi.StrictServerInterface.
+func (s Server) UpdateUser(ctx context.Context, request oapi.UpdateUserRequestObject) (oapi.UpdateUserResponseObject, error) {
+
+	params := sqlc.UpdateUserParams{
+		AvatarID: request.Body.AvatarId,
+		DispName: request.Body.DispName,
+		UserDesc: request.Body.UserDesc,
+		Mail:     EmailToStringPtr(request.Body.Mail),
+		UserID:   request.UserId,
+	}
+
+	user, err := s.db.UpdateUser(ctx, params)
+	if err != nil {
+		log.Errorf("%v", err)
+		return oapi.UpdateUser500Response{}, nil
+	}
+
+	oapi_user := oapi.User{ // maybe its possible to make one sqlc type and use one map func iinstead of this shit
+		// AvatarId:     user.AvatarID,
+		CreationDate: &user.CreationDate,
+		DispName:     user.DispName,
+		Id:           &user.ID,
+		Mail:         StringToEmail(user.Mail),
+		Nickname:     user.Nickname,
+		UserDesc:     user.UserDesc,
+	}
+
+	return oapi.UpdateUser200JSONResponse(oapi_user), nil
+}
+
+func (s Server) AddUserTitle(ctx context.Context, request oapi.AddUserTitleRequestObject) (oapi.AddUserTitleResponseObject, error) {
+	//TODO: add review if exists
+	status, err := UserTitleStatus2Sqlc1(&request.Body.Status)
+	if err != nil {
+		log.Errorf("%v", err)
+		return oapi.AddUserTitle400Response{}, nil
+	}
+
+	params := sqlc.InsertUserTitleParams{
+		UserID:  request.UserId,
+		TitleID: request.Body.TitleId,
+		Status:  *status,
+		Rate:    request.Body.Rate,
+	}
+
+	user_title, err := s.db.InsertUserTitle(ctx, params)
+	if err != nil {
+		var pgErr *pgconn.PgError
+		if errors.As(err, &pgErr) {
+			// fmt.Println(pgErr.Message) // => syntax error at end of input
+			// fmt.Println(pgErr.Code)    // => 42601
+			if pgErr.Code == pgErrDuplicateKey { //duplicate key value
+				return oapi.AddUserTitle409Response{}, nil
+			}
+		} else {
+			log.Errorf("%v", err)
+			return oapi.AddUserTitle500Response{}, nil
+		}
+	}
+	oapi_status, err := sql2usertitlestatus(user_title.Status)
+	if err != nil {
+		log.Errorf("%v", err)
+		return oapi.AddUserTitle500Response{}, nil
+	}
+	oapi_usertitle := oapi.UserTitleMini{
+		Ctime:    &user_title.Ctime,
+		Rate:     user_title.Rate,
+		ReviewId: user_title.ReviewID,
+		Status:   oapi_status,
+		TitleId:  user_title.TitleID,
+		UserId:   user_title.UserID,
+	}
+
+	return oapi.AddUserTitle200JSONResponse(oapi_usertitle), nil
+}
+
+// DeleteUserTitle implements oapi.StrictServerInterface.
+func (s Server) DeleteUserTitle(ctx context.Context, request oapi.DeleteUserTitleRequestObject) (oapi.DeleteUserTitleResponseObject, error) {
+	params := sqlc.DeleteUserTitleParams{
+		UserID:  request.UserId,
+		TitleID: request.TitleId,
+	}
+	_, err := s.db.DeleteUserTitle(ctx, params)
+	if err != nil {
+		if err == pgx.ErrNoRows {
+			return oapi.DeleteUserTitle404Response{}, nil
+		}
+		log.Errorf("%v", err)
+		return oapi.DeleteUserTitle500Response{}, nil
+	}
+	return oapi.DeleteUserTitle200Response{}, nil
+}
+
+// UpdateUserTitle implements oapi.StrictServerInterface.
+func (s Server) UpdateUserTitle(ctx context.Context, request oapi.UpdateUserTitleRequestObject) (oapi.UpdateUserTitleResponseObject, error) {
+
+	status, err := UserTitleStatus2Sqlc1(request.Body.Status)
+	if err != nil {
+		log.Errorf("%v", err)
+		return oapi.UpdateUserTitle400Response{}, nil
+	}
+	params := sqlc.UpdateUserTitleParams{
+		Status:  status,
+		Rate:    request.Body.Rate,
+		UserID:  request.UserId,
+		TitleID: request.TitleId,
+	}
+
+	user_title, err := s.db.UpdateUserTitle(ctx, params)
+	if err != nil {
+		if err == pgx.ErrNoRows {
+			return oapi.UpdateUserTitle404Response{}, nil
+		}
+		log.Errorf("%v", err)
+		return oapi.UpdateUserTitle500Response{}, nil
+	}
+	oapi_status, err := sql2usertitlestatus(user_title.Status)
+	if err != nil {
+		log.Errorf("%v", err)
+		return oapi.UpdateUserTitle500Response{}, nil
+	}
+
+	oapi_usertitle := oapi.UserTitleMini{
+		Ctime:    &user_title.Ctime,
+		Rate:     user_title.Rate,
+		ReviewId: user_title.ReviewID,
+		Status:   oapi_status,
+		TitleId:  user_title.TitleID,
+		UserId:   user_title.UserID,
+	}
+
+	return oapi.UpdateUserTitle200JSONResponse(oapi_usertitle), nil
+}
+
+func (s Server) GetUserTitle(ctx context.Context, request oapi.GetUserTitleRequestObject) (oapi.GetUserTitleResponseObject, error) {
+	user_title, err := s.db.GetUserTitleByID(ctx, sqlc.GetUserTitleByIDParams{
+		TitleID: request.TitleId,
+		UserID:  request.UserId,
+	})
+	if err != nil {
+		if err == pgx.ErrNoRows {
+			return oapi.GetUserTitle404Response{}, nil
+		} else {
+			log.Errorf("%v", err)
+			return oapi.GetUserTitle500Response{}, nil
+		}
+	}
+	oapi_status, err := sql2usertitlestatus(user_title.Status)
+	if err != nil {
+		log.Errorf("%v", err)
+		return oapi.GetUserTitle500Response{}, nil
+	}
+	oapi_usertitle := oapi.UserTitleMini{
+		Ctime:    &user_title.Ctime,
+		Rate:     user_title.Rate,
+		ReviewId: user_title.ReviewID,
+		Status:   oapi_status,
+		TitleId:  user_title.TitleID,
+		UserId:   user_title.UserID,
+	}
+
+	return oapi.GetUserTitle200JSONResponse(oapi_usertitle), nil
 }

modules/backend/main.go

@@ -3,6 +3,7 @@ package main
 import (
 	"context"
 	"fmt"
+	"net/http"
 	sqlc "nyanimedb/sql"
 	"os"
 	"reflect"
@@ -10,46 +11,64 @@ import (
 
 	oapi "nyanimedb/api"
 	handlers "nyanimedb/modules/backend/handlers"
+	middleware "nyanimedb/modules/backend/middlewares"
+	"nyanimedb/modules/backend/rmq"
 
 	"github.com/gin-contrib/cors"
 	"github.com/gin-gonic/gin"
-	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
 	"github.com/pelletier/go-toml/v2"
+	"github.com/rabbitmq/amqp091-go"
+	log "github.com/sirupsen/logrus"
 )
 
 var AppConfig Config
 
 func main() {
-	// if len(os.Args) != 2 {
-	// 	AppConfig.Mode = "env"
-	// } else {
-	// 	AppConfig.Mode = "argv"
-	// }
+	if len(os.Args) != 2 {
+		AppConfig.Mode = "env"
+	} else {
+		AppConfig.Mode = "argv"
+	}
 
-	// err := InitConfig()
-	// if err != nil {
-	// 	log.Fatalf("Failed to init config: %v\n", err)
-	// }
+	err := InitConfig()
+	if err != nil {
+		log.Fatalf("Failed to init config: %v\n", err)
+	}
 
-	conn, err := pgx.Connect(context.Background(), os.Getenv("DATABASE_URL"))
+	pool, err := pgxpool.New(context.Background(), AppConfig.DdUrl)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "Unable to connect to database: %v\n", err)
 		os.Exit(1)
 	}
 
-	defer conn.Close(context.Background())
+	defer pool.Close()
 
 	r := gin.Default()
 
-	queries := sqlc.New(conn)
+	if len(AppConfig.AuthEnabled) > 0 && AppConfig.AuthEnabled != "false" {
+		r.Use(middleware.CSRFMiddleware())
+		r.Use(middleware.JWTAuthMiddleware(AppConfig.JwtPrivateKey))
+	}
 
-	server := handlers.NewServer(queries)
-	// r.LoadHTMLGlob("templates/*")
+	queries := sqlc.New(pool)
+
+	rmqConn, err := amqp091.Dial(AppConfig.RmqURL)
+	if err != nil {
+		log.Fatalf("Failed to connect to RabbitMQ: %v", err)
+	}
+	defer rmqConn.Close()
+
+	publisher := rmq.NewPublisher(rmqConn)
+	rpcClient := rmq.NewRPCClient(rmqConn, 30*time.Second)
+
+	server := handlers.NewServer(queries, publisher, rpcClient)
 
 	r.Use(cors.New(cors.Config{
-		AllowOrigins:     []string{"*"}, // allow all origins, change to specific domains in production
-		AllowMethods:     []string{"GET", "POST", "PUT", "DELETE"},
-		AllowHeaders:     []string{"Origin", "Content-Type", "Accept"},
+		AllowOrigins: []string{AppConfig.ServiceAddress},
+		// AllowOrigins:     []string{"*"},
+		AllowMethods:     []string{"GET", "POST", "PUT", "DELETE", "PATCH"},
+		AllowHeaders:     []string{"Origin", "Content-Type", "Accept", "X-XSRF-TOKEN"},
 		ExposeHeaders:    []string{"Content-Length"},
 		AllowCredentials: true,
 		MaxAge:           12 * time.Hour,
@@ -57,27 +76,15 @@ func main() {
 
 	oapi.RegisterHandlers(r, oapi.NewStrictHandler(
 		server,
-		// сюда можно добавить middlewares, если нужно
+
 		[]oapi.StrictMiddlewareFunc{},
 	))
-	// r.GET("/", func(c *gin.Context) {
-	// 	c.HTML(http.StatusOK, "index.html", gin.H{
-	// 		"title":   "Welcome Page",
-	// 		"message": "Hello, Gin with HTML templates!",
-	// 	})
-	// })
 
-	// r.GET("/api", func(c *gin.Context) {
-	// 	items := []Item{
-	// 		{ID: 1, Title: "First Item", Description: "This is the description of the first item."},
-	// 		{ID: 2, Title: "Second Item", Description: "This is the description of the second item."},
-	// 		{ID: 3, Title: "Third Item", Description: "This is the description of the third item."},
-	// 	}
-
-	// 	c.JSON(http.StatusOK, items)
-	// })
-
-	r.Run(":8080")
+	// Запуск
+	log.Infof("Server starting on :8080")
+	if err := r.Run(":8080"); err != nil && err != http.ErrServerClosed {
+		log.Fatalf("server failed: %v", err)
+	}
 }
 
 func InitConfig() error {

modules/backend/middlewares/access.go

@@ -0,0 +1,109 @@
+package middleware
+
+import (
+	"context"
+	"errors"
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+	"github.com/golang-jwt/jwt/v5"
+)
+
+// ctxKey — приватный тип для ключа контекста
+type ctxKey struct{}
+
+// ginContextKey — уникальный ключ для хранения *gin.Context
+var ginContextKey = &ctxKey{}
+
+// GinContextToContext сохраняет *gin.Context в context.Context запроса
+func GinContextToContext(c *gin.Context) {
+	ctx := context.WithValue(c.Request.Context(), ginContextKey, c)
+	c.Request = c.Request.WithContext(ctx)
+}
+
+// GinContextFromContext извлекает *gin.Context из context.Context
+func GinContextFromContext(ctx context.Context) (*gin.Context, bool) {
+	ginCtx, ok := ctx.Value(ginContextKey).(*gin.Context)
+	return ginCtx, ok
+}
+
+func JWTAuthMiddleware(secret string) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		// 1. Получаем access_token из cookie
+		tokenStr, err := c.Cookie("access_token")
+		if err != nil {
+			abortWithJSON(c, http.StatusUnauthorized, "missing access_token cookie")
+			return
+		}
+
+		// 2. Парсим токен с MapClaims
+		token, err := jwt.Parse(tokenStr, func(t *jwt.Token) (interface{}, error) {
+			if t.Method != jwt.SigningMethodHS256 {
+				return nil, errors.New("unexpected signing method: " + t.Method.Alg())
+			}
+			return []byte(secret), nil // ← конвертируем string → []byte
+		})
+		if err != nil {
+			abortWithJSON(c, http.StatusUnauthorized, "invalid token: "+err.Error())
+			return
+		}
+
+		// 3. Проверяем валидность
+		if !token.Valid {
+			abortWithJSON(c, http.StatusUnauthorized, "token is invalid")
+			return
+		}
+
+		// 4. Извлекаем user_id из claims
+		claims, ok := token.Claims.(jwt.MapClaims)
+		if !ok {
+			abortWithJSON(c, http.StatusUnauthorized, "invalid claims format")
+			return
+		}
+
+		userID, ok := claims["user_id"].(string)
+		if !ok || userID == "" {
+			abortWithJSON(c, http.StatusUnauthorized, "user_id claim missing or invalid")
+			return
+		}
+
+		// 5. Сохраняем в контексте
+		c.Set("user_id", userID)
+
+		// 6. Для oapi-codegen — кладём gin.Context в request context
+		GinContextToContext(c)
+
+		c.Next()
+	}
+}
+
+// Вспомогательные функции (без изменений)
+func UserIDFromGin(c *gin.Context) (string, bool) {
+	id, exists := c.Get("user_id")
+	if !exists {
+		return "", false
+	}
+	if s, ok := id.(string); ok {
+		return s, true
+	}
+	return "", false
+}
+
+func UserIDFromContext(ctx context.Context) (string, error) {
+	ginCtx, ok := GinContextFromContext(ctx)
+	if !ok {
+		return "", errors.New("gin context not found")
+	}
+	userID, ok := UserIDFromGin(ginCtx)
+	if !ok {
+		return "", errors.New("user_id not found in context")
+	}
+	return userID, nil
+}
+
+func abortWithJSON(c *gin.Context, code int, message string) {
+	c.AbortWithStatusJSON(code, gin.H{
+		"error":   "unauthorized",
+		"message": message,
+	})
+}

modules/backend/middlewares/csrf.go

@@ -0,0 +1,70 @@
+package middleware
+
+import (
+	"crypto/subtle"
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+)
+
+// CSRFMiddleware для Gin
+func CSRFMiddleware() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		// Пропускаем безопасные методы
+		if !isStateChangingMethod(c.Request.Method) {
+			c.Next()
+			return
+		}
+
+		// 1. Получаем токен из заголовка
+		headerToken := c.GetHeader("X-XSRF-TOKEN")
+		if headerToken == "" {
+			c.AbortWithStatusJSON(http.StatusForbidden, gin.H{
+				"error": "missing X-XSRF-TOKEN header",
+			})
+			return
+		}
+
+		// 2. Получаем токен из cookie
+		cookie, err := c.Cookie("xsrf_token")
+		if err != nil {
+			c.AbortWithStatusJSON(http.StatusForbidden, gin.H{
+				"error": "missing xsrf_token cookie",
+			})
+			return
+		}
+
+		// 3. Безопасное сравнение
+		if subtle.ConstantTimeCompare([]byte(headerToken), []byte(cookie)) != 1 {
+			c.AbortWithStatusJSON(http.StatusForbidden, gin.H{
+				"error": "CSRF token mismatch",
+			})
+			return
+		}
+
+		// 4. Опционально: сохраняем токен в контексте
+		c.Set("csrf_token", headerToken)
+		c.Next()
+	}
+}
+
+func isStateChangingMethod(method string) bool {
+	switch method {
+	case http.MethodPost, http.MethodPut, http.MethodPatch, http.MethodDelete:
+		return true
+	default:
+		return false
+	}
+}
+
+// CSRFTokenFromGin извлекает токен из Gin context
+func CSRFTokenFromGin(c *gin.Context) (string, bool) {
+	token, exists := c.Get("xsrf_token")
+	if !exists {
+		return "", false
+	}
+	if s, ok := token.(string); ok {
+		return s, true
+	}
+	return "", false
+}

modules/backend/queries.sql

@@ -1,7 +1,7 @@
 -- name: GetImageByID :one
 SELECT id, storage_type, image_path
 FROM images
-WHERE id = sqlc.arg('illust_id');
+WHERE id = sqlc.arg('illust_id')::bigint;
 
 -- name: CreateImage :one
 INSERT INTO images (storage_type, image_path)
@@ -9,9 +9,19 @@ VALUES ($1, $2)
 RETURNING id, storage_type, image_path;
 
 -- name: GetUserByID :one
-SELECT id, avatar_id, mail, nickname, disp_name, user_desc, creation_date
-FROM users
-WHERE id = $1;
+SELECT 
+    t.id                as id,
+    t.avatar_id         as avatar_id,
+    t.mail              as mail,
+    t.nickname          as nickname,
+    t.disp_name         as disp_name,
+    t.user_desc         as user_desc,
+    t.creation_date     as creation_date,
+    i.storage_type      as storage_type,
+    i.image_path        as image_path
+FROM users as t
+LEFT JOIN images as i ON (t.avatar_id = i.id)
+WHERE t.id = sqlc.arg('id')::bigint;
 
 
 -- name: GetStudioByID :one
@@ -47,162 +57,347 @@ VALUES (
     sqlc.arg('tag_names')::jsonb)
 RETURNING id, tag_names;
 
--- -- name: ListUsers :many
--- SELECT user_id, avatar_id, passhash, mail, nickname, disp_name, user_desc, creation_date
--- FROM users
--- ORDER BY user_id
--- LIMIT $1 OFFSET $2;
-
--- -- name: CreateUser :one
--- INSERT INTO users (avatar_id, passhash, mail, nickname, disp_name, user_desc, creation_date)
--- VALUES ($1, $2, $3, $4, $5, $6, $7)
--- RETURNING user_id, avatar_id, nickname, disp_name, user_desc, creation_date;
-
--- -- name: UpdateUser :one
--- UPDATE users
--- SET
---   avatar_id = COALESCE(sqlc.narg('avatar_id'), avatar_id),
---   disp_name = COALESCE(sqlc.narg('disp_name'), disp_name),
---   user_desc = COALESCE(sqlc.narg('user_desc'), user_desc),
---   passhash  = COALESCE(sqlc.narg('passhash'), passhash)
--- WHERE user_id = sqlc.arg('user_id')
--- RETURNING user_id, avatar_id, nickname, disp_name, user_desc, creation_date;
-
--- -- name: DeleteUser :exec
--- DELETE FROM users
--- WHERE user_id = $1;
+-- name: UpdateUser :one
+UPDATE users
+SET
+  avatar_id = COALESCE(sqlc.narg('avatar_id'), avatar_id),
+  disp_name = COALESCE(sqlc.narg('disp_name'), disp_name),
+  user_desc = COALESCE(sqlc.narg('user_desc'), user_desc),
+  mail      = COALESCE(sqlc.narg('mail'), mail)
+WHERE id = sqlc.arg('user_id')
+RETURNING id, avatar_id, nickname, disp_name, user_desc, creation_date, mail;
 
 -- name: GetTitleByID :one
-SELECT *
-FROM titles
-WHERE id = sqlc.arg('title_id')::bigint;
+-- sqlc.struct: TitlesFull
+SELECT 
+    t.*,
+    i.storage_type                          as title_storage_type,
+    i.image_path                            as title_image_path,
+    COALESCE(
+        jsonb_agg(g.tag_names) FILTER (WHERE g.tag_names IS NOT NULL),
+        '[]'::jsonb
+    )::jsonb                                as tag_names,
+    s.studio_name                           as studio_name,
+    s.illust_id                             as studio_illust_id,
+    s.studio_desc                           as studio_desc,
+    si.storage_type                         as studio_storage_type,
+    si.image_path                           as studio_image_path
+
+FROM titles          as t
+LEFT JOIN images     as i    ON (t.poster_id = i.id)
+LEFT JOIN title_tags as tt   ON (t.id = tt.title_id)
+LEFT JOIN tags       as g    ON (tt.tag_id = g.id)
+LEFT JOIN studios    as s    ON (t.studio_id = s.id)
+LEFT JOIN images     as si   ON (s.illust_id = si.id)
+
+WHERE t.id = sqlc.arg('title_id')::bigint
+GROUP BY 
+    t.id, i.id, s.id, si.id;
 
 -- name: SearchTitles :many
 SELECT 
-    *
-FROM titles
-WHERE 
-    CASE 
-        WHEN sqlc.narg('word')::text IS NOT NULL THEN
-            (
-                SELECT bool_and(
-                    EXISTS (
-                        SELECT 1 
-                        FROM jsonb_each_text(title_names) AS t(key, val)
-                        WHERE val ILIKE pattern
-                    )
-                )
-                FROM unnest(
-                    ARRAY(
-                        SELECT '%' || trim(w) || '%'
-                        FROM unnest(string_to_array(sqlc.narg('word')::text, ' ')) AS w
-                        WHERE trim(w) <> ''
-                    )
-                ) AS pattern
-            )
-        ELSE true
+    t.id                                    as id,
+    t.title_names                           as title_names,
+    t.poster_id                             as poster_id,
+    t.title_status                          as title_status,
+    t.rating                                as rating,
+    t.rating_count                          as rating_count,
+    t.release_year                          as release_year,
+    t.release_season                        as release_season,
+    t.season                                as season,
+    t.episodes_aired                        as episodes_aired,
+    t.episodes_all                          as episodes_all,
+    i.storage_type                          as title_storage_type,
+    i.image_path                            as title_image_path,
+    COALESCE(
+        jsonb_agg(g.tag_names) FILTER (WHERE g.tag_names IS NOT NULL),
+        '[]'::jsonb
+    )::jsonb                                as tag_names,
+    s.studio_name                           as studio_name
+
+FROM titles          as t
+LEFT JOIN images     as i    ON (t.poster_id = i.id)
+LEFT JOIN title_tags as tt   ON (t.id = tt.title_id)
+LEFT JOIN tags       as g    ON (tt.tag_id = g.id)
+LEFT JOIN studios    as s    ON (t.studio_id = s.id)
+
+WHERE
+    CASE
+        WHEN sqlc.arg('forward')::boolean THEN
+        -- forward: greater than cursor (next page)
+            CASE sqlc.arg('sort_by')::text
+                WHEN 'year' THEN
+                    (sqlc.narg('cursor_year')::int IS NULL) OR
+                    (t.release_year > sqlc.narg('cursor_year')::int) OR
+                    (t.release_year = sqlc.narg('cursor_year')::int AND t.id > sqlc.narg('cursor_id')::bigint)
+
+                WHEN 'rating' THEN
+                        (sqlc.narg('cursor_rating')::float IS NULL) OR
+                        (t.rating > sqlc.narg('cursor_rating')::float) OR
+                        (t.rating = sqlc.narg('cursor_rating')::float AND t.id > sqlc.narg('cursor_id')::bigint)
+
+                WHEN 'id' THEN
+                    (sqlc.narg('cursor_id')::bigint IS NULL) OR
+                    (t.id > sqlc.narg('cursor_id')::bigint)
+
+                ELSE true  -- fallback
+            END
+
+    ELSE
+        -- backward: less than cursor (prev page)
+        CASE sqlc.arg('sort_by')::text
+            WHEN 'year' THEN
+                (sqlc.narg('cursor_year')::int IS NULL) OR
+                (t.release_year < sqlc.narg('cursor_year')::int) OR
+                (t.release_year = sqlc.narg('cursor_year')::int AND t.id < sqlc.narg('cursor_id')::bigint)
+
+            WHEN 'rating' THEN
+                (sqlc.narg('cursor_rating')::float IS NULL) OR
+                (t.rating < sqlc.narg('cursor_rating')::float) OR
+                (t.rating = sqlc.narg('cursor_rating')::float AND t.id < sqlc.narg('cursor_id')::bigint)
+
+            WHEN 'id' THEN
+                (sqlc.narg('cursor_id')::bigint IS NULL) OR
+                (t.id < sqlc.narg('cursor_id')::bigint)
+
+            ELSE true
+        END
     END
 
-    AND (sqlc.narg('status')::title_status_t IS NULL OR title_status = sqlc.narg('status')::title_status_t)
-    AND (sqlc.narg('rating')::float IS NULL OR rating >= sqlc.narg('rating')::float)
-    AND (sqlc.narg('release_year')::int IS NULL OR release_year = sqlc.narg('release_year')::int)
-    AND (sqlc.narg('release_season')::release_season_t IS NULL OR release_season = sqlc.narg('release_season')::release_season_t)
+    AND (
+        CASE 
+            WHEN sqlc.narg('word')::text IS NOT NULL THEN
+                (
+                    SELECT bool_and(
+                        EXISTS (
+                            SELECT 1 
+                            FROM jsonb_each_text(t.title_names) AS t(key, val)
+                            WHERE val ILIKE pattern
+                        )
+                    )
+                    FROM unnest(
+                        ARRAY(
+                            SELECT '%' || trim(w) || '%'
+                            FROM unnest(string_to_array(sqlc.narg('word')::text, ' ')) AS w
+                            WHERE trim(w) <> ''
+                        )
+                    ) AS pattern
+                )
+            ELSE true
+        END
+    )
 
-LIMIT COALESCE(sqlc.narg('limit')::int, 100) -- 100 is default limit
-OFFSET sqlc.narg('offset')::int;
+    AND (
+        sqlc.narg('title_statuses')::title_status_t[] IS NULL
+        OR array_length(sqlc.narg('title_statuses')::title_status_t[], 1) IS NULL
+        OR array_length(sqlc.narg('title_statuses')::title_status_t[], 1) = 0
+        OR t.title_status = ANY(sqlc.narg('title_statuses')::title_status_t[])
+    )
+    AND (sqlc.narg('rating')::float IS NULL OR t.rating >= sqlc.narg('rating')::float)
+    AND (sqlc.narg('release_year')::int IS NULL OR t.release_year = sqlc.narg('release_year')::int)
+    AND (sqlc.narg('release_season')::release_season_t IS NULL OR t.release_season = sqlc.narg('release_season')::release_season_t)
 
--- -- name: ListTitles :many
--- SELECT title_id, title_names, studio_id, poster_id, signal_ids,
---        title_status, rating, rating_count, release_year, release_season,
---        season, episodes_aired, episodes_all, episodes_len
--- FROM titles
--- ORDER BY title_id
--- LIMIT $1 OFFSET $2;
+GROUP BY 
+    t.id, i.id, s.id
 
--- -- name: UpdateTitle :one
--- UPDATE titles
--- SET
---   title_names = COALESCE(sqlc.narg('title_names'), title_names),
---   studio_id = COALESCE(sqlc.narg('studio_id'), studio_id),
---   poster_id = COALESCE(sqlc.narg('poster_id'), poster_id),
---   signal_ids = COALESCE(sqlc.narg('signal_ids'), signal_ids),
---   title_status = COALESCE(sqlc.narg('title_status'), title_status),
---   release_year = COALESCE(sqlc.narg('release_year'), release_year),
---   release_season = COALESCE(sqlc.narg('release_season'), release_season),
---   episodes_aired = COALESCE(sqlc.narg('episodes_aired'), episodes_aired),
---   episodes_all = COALESCE(sqlc.narg('episodes_all'), episodes_all),
---   episodes_len = COALESCE(sqlc.narg('episodes_len'), episodes_len)
--- WHERE title_id = sqlc.arg('title_id')
--- RETURNING *;
+ORDER BY
+    CASE WHEN sqlc.arg('forward')::boolean THEN
+        CASE
+            WHEN sqlc.arg('sort_by')::text = 'id' THEN t.id
+            WHEN sqlc.arg('sort_by')::text = 'year' THEN t.release_year
+            WHEN sqlc.arg('sort_by')::text = 'rating' THEN t.rating
+        END
+    END ASC,
+    CASE WHEN NOT sqlc.arg('forward')::boolean THEN
+        CASE
+            WHEN sqlc.arg('sort_by')::text = 'id' THEN t.id
+            WHEN sqlc.arg('sort_by')::text = 'year' THEN t.release_year
+            WHEN sqlc.arg('sort_by')::text = 'rating' THEN t.rating
+        END
+    END DESC,
+
+    CASE WHEN sqlc.arg('sort_by')::text <> 'id' THEN t.id END ASC
+
+LIMIT COALESCE(sqlc.narg('limit')::int, 100); -- 100 is default limit
+
+-- name: SearchUserTitles :many
+SELECT
+    t.id                                    as id,
+    t.title_names                           as title_names,
+    t.poster_id                             as poster_id,
+    t.title_status                          as title_status,
+    t.rating                                as rating,
+    t.rating_count                          as rating_count,
+    t.release_year                          as release_year,
+    t.release_season                        as release_season,
+    t.season                                as season,
+    t.episodes_aired                        as episodes_aired,
+    t.episodes_all                          as episodes_all,
+    u.user_id                               as user_id,
+    u.status                                as usertitle_status,
+    u.rate                                  as user_rate,
+    u.review_id                             as review_id,
+    u.ctime                                 as user_ctime,
+    i.storage_type                          as title_storage_type,
+    i.image_path                            as title_image_path,
+    COALESCE(
+        jsonb_agg(g.tag_names) FILTER (WHERE g.tag_names IS NOT NULL),
+        '[]'::jsonb
+    )::jsonb                                as tag_names,
+    s.studio_name                           as studio_name
+
+FROM usertitles         as u
+JOIN titles             as t    ON (u.title_id = t.id)
+LEFT JOIN images        as i    ON (t.poster_id = i.id)
+LEFT JOIN title_tags    as tt   ON (t.id = tt.title_id)
+LEFT JOIN tags          as g    ON (tt.tag_id = g.id)
+LEFT JOIN studios       as s    ON (t.studio_id = s.id)
+
+WHERE
+    u.user_id = sqlc.arg('user_id')::bigint
+    AND
+    CASE
+        WHEN sqlc.arg('forward')::boolean THEN
+        -- forward: greater than cursor (next page)
+            CASE sqlc.arg('sort_by')::text
+                WHEN 'year' THEN
+                    (sqlc.narg('cursor_year')::int IS NULL) OR
+                    (t.release_year > sqlc.narg('cursor_year')::int) OR
+                    (t.release_year = sqlc.narg('cursor_year')::int AND t.id > sqlc.narg('cursor_id')::bigint)
+
+                WHEN 'rating' THEN
+                        (sqlc.narg('cursor_rating')::float IS NULL) OR
+                        (t.rating > sqlc.narg('cursor_rating')::float) OR
+                        (t.rating = sqlc.narg('cursor_rating')::float AND t.id > sqlc.narg('cursor_id')::bigint)
+
+                WHEN 'id' THEN
+                    (sqlc.narg('cursor_id')::bigint IS NULL) OR
+                    (t.id > sqlc.narg('cursor_id')::bigint)
+
+                ELSE true  -- fallback
+            END
+
+    ELSE
+        -- backward: less than cursor (prev page)
+        CASE sqlc.arg('sort_by')::text
+            WHEN 'year' THEN
+                (sqlc.narg('cursor_year')::int IS NULL) OR
+                (t.release_year < sqlc.narg('cursor_year')::int) OR
+                (t.release_year = sqlc.narg('cursor_year')::int AND t.id < sqlc.narg('cursor_id')::bigint)
+
+            WHEN 'rating' THEN
+                (sqlc.narg('cursor_rating')::float IS NULL) OR
+                (t.rating < sqlc.narg('cursor_rating')::float) OR
+                (t.rating = sqlc.narg('cursor_rating')::float AND t.id < sqlc.narg('cursor_id')::bigint)
+
+            WHEN 'id' THEN
+                (sqlc.narg('cursor_id')::bigint IS NULL) OR
+                (t.id < sqlc.narg('cursor_id')::bigint)
+
+            ELSE true
+        END
+    END
+
+    AND (
+        CASE 
+            WHEN sqlc.narg('word')::text IS NOT NULL THEN
+                (
+                    SELECT bool_and(
+                        EXISTS (
+                            SELECT 1 
+                            FROM jsonb_each_text(t.title_names) AS t(key, val)
+                            WHERE val ILIKE pattern
+                        )
+                    )
+                    FROM unnest(
+                        ARRAY(
+                            SELECT '%' || trim(w) || '%'
+                            FROM unnest(string_to_array(sqlc.narg('word')::text, ' ')) AS w
+                            WHERE trim(w) <> ''
+                        )
+                    ) AS pattern
+                )
+            ELSE true
+        END
+    )
+
+    AND (
+        sqlc.narg('title_statuses')::title_status_t[] IS NULL
+        OR array_length(sqlc.narg('title_statuses')::title_status_t[], 1) IS NULL
+        OR array_length(sqlc.narg('title_statuses')::title_status_t[], 1) = 0
+        OR t.title_status = ANY(sqlc.narg('title_statuses')::title_status_t[])
+    )
+    AND (
+        sqlc.narg('usertitle_statuses')::usertitle_status_t[] IS NULL
+        OR array_length(sqlc.narg('usertitle_statuses')::usertitle_status_t[], 1) IS NULL
+        OR array_length(sqlc.narg('usertitle_statuses')::usertitle_status_t[], 1) = 0
+        OR u.status = ANY(sqlc.narg('usertitle_statuses')::usertitle_status_t[])
+    )
+    AND (sqlc.narg('rate')::int IS NULL OR u.rate >= sqlc.narg('rate')::int)
+    AND (sqlc.narg('rating')::float IS NULL OR t.rating >= sqlc.narg('rating')::float)
+    AND (sqlc.narg('release_year')::int IS NULL OR t.release_year = sqlc.narg('release_year')::int)
+    AND (sqlc.narg('release_season')::release_season_t IS NULL OR t.release_season = sqlc.narg('release_season')::release_season_t)
+
+GROUP BY 
+    t.id, u.user_id, u.status, u.rate, u.review_id, u.ctime, i.id, s.id
+
+ORDER BY
+    CASE WHEN sqlc.arg('forward')::boolean THEN
+        CASE
+            WHEN sqlc.arg('sort_by')::text = 'id' THEN t.id
+            WHEN sqlc.arg('sort_by')::text = 'year' THEN t.release_year
+            WHEN sqlc.arg('sort_by')::text = 'rating' THEN t.rating
+            WHEN sqlc.arg('sort_by')::text = 'rate' THEN u.rate
+        END
+    END ASC,
+    CASE WHEN NOT sqlc.arg('forward')::boolean THEN
+        CASE
+            WHEN sqlc.arg('sort_by')::text = 'id' THEN t.id
+            WHEN sqlc.arg('sort_by')::text = 'year' THEN t.release_year
+            WHEN sqlc.arg('sort_by')::text = 'rating' THEN t.rating
+            WHEN sqlc.arg('sort_by')::text = 'rate' THEN u.rate
+        END
+    END DESC,
+
+    CASE WHEN sqlc.arg('sort_by')::text <> 'id' THEN t.id END ASC
+
+LIMIT COALESCE(sqlc.narg('limit')::int, 100); -- 100 is default limit
 
 -- name: GetReviewByID :one
 SELECT *
 FROM reviews
 WHERE review_id = sqlc.arg('review_id')::bigint;
 
--- -- name: CreateReview :one
--- INSERT INTO reviews (user_id, title_id, image_ids, review_text, creation_date)
--- VALUES ($1, $2, $3, $4, $5)
--- RETURNING review_id, user_id, title_id, image_ids, review_text, creation_date;
+-- name: InsertUserTitle :one
+INSERT INTO usertitles (user_id, title_id, status, rate, review_id)
+VALUES (   
+    sqlc.arg('user_id')::bigint,
+    sqlc.arg('title_id')::bigint,
+    sqlc.arg('status')::usertitle_status_t,
+    sqlc.narg('rate')::int,
+    sqlc.narg('review_id')::bigint
+)
+RETURNING user_id, title_id, status, rate, review_id, ctime;
 
--- -- name: UpdateReview :one
--- UPDATE reviews
--- SET
---   image_ids = COALESCE(sqlc.narg('image_ids'), image_ids),
---   review_text = COALESCE(sqlc.narg('review_text'), review_text)
--- WHERE review_id = sqlc.arg('review_id')
--- RETURNING *;
+-- name: UpdateUserTitle :one
+-- Fails with sql.ErrNoRows if (user_id, title_id) not found
+UPDATE usertitles
+SET
+    status = COALESCE(sqlc.narg('status')::usertitle_status_t, status),
+    rate   = COALESCE(sqlc.narg('rate')::int, rate)
+WHERE
+    user_id = sqlc.arg('user_id')
+    AND title_id = sqlc.arg('title_id')
+RETURNING *;
 
--- -- name: DeleteReview :exec
--- DELETE FROM reviews
--- WHERE review_id = $1;
+-- name: DeleteUserTitle :one
+DELETE FROM usertitles
+WHERE user_id = sqlc.arg('user_id')
+  AND title_id = sqlc.arg('title_id')
+RETURNING *;
 
--- name: ListReviewsByTitle :many
--- SELECT review_id, user_id, title_id, image_ids, review_text, creation_date
--- FROM reviews
--- WHERE title_id = $1
--- ORDER BY creation_date DESC
--- LIMIT $2 OFFSET $3;
-
--- -- name: ListReviewsByUser :many
--- SELECT review_id, user_id, title_id, image_ids, review_text, creation_date
--- FROM reviews
--- WHERE user_id = $1
--- ORDER BY creation_date DESC
--- LIMIT $2 OFFSET $3;
-
--- -- name: GetUserTitle :one
--- SELECT usertitle_id, user_id, title_id, status, rate, review_id
--- FROM usertitles
--- WHERE user_id = $1 AND title_id = $2;
-
--- -- name: ListUserTitles :many
--- SELECT usertitle_id, user_id, title_id, status, rate, review_id
--- FROM usertitles
--- WHERE user_id = $1
--- ORDER BY usertitle_id
--- LIMIT $2 OFFSET $3;
-
--- -- name: CreateUserTitle :one
--- INSERT INTO usertitles (user_id, title_id, status, rate, review_id)
--- VALUES ($1, $2, $3, $4, $5)
--- RETURNING usertitle_id, user_id, title_id, status, rate, review_id;
-
--- -- name: UpdateUserTitle :one
--- UPDATE usertitles
--- SET
---   status = COALESCE(sqlc.narg('status'), status),
---   rate = COALESCE(sqlc.narg('rate'), rate),
---   review_id = COALESCE(sqlc.narg('review_id'), review_id)
--- WHERE user_id = $1 AND title_id = $2
--- RETURNING *;
-
--- -- name: DeleteUserTitle :exec
--- DELETE FROM usertitles
--- WHERE user_id = $1 AND ($2::int IS NULL OR title_id = $2);
-
--- -- name: ListTags :many
--- SELECT tag_id, tag_names
--- FROM tags
--- ORDER BY tag_id
--- LIMIT $1 OFFSET $2;
+-- name: GetUserTitleByID :one
+SELECT 
+    ut.*
+FROM usertitles      as ut
+WHERE ut.title_id = sqlc.arg('title_id')::bigint AND ut.user_id = sqlc.arg('user_id')::bigint;

modules/backend/rmq/rabbit.go

@@ -0,0 +1,261 @@
+package rmq
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	oapi "nyanimedb/api"
+	"sync"
+	"time"
+
+	amqp "github.com/rabbitmq/amqp091-go"
+)
+
+type RabbitRequest struct {
+	Name      string             `json:"name"`
+	Statuses  []oapi.TitleStatus `json:"statuses,omitempty"`
+	Rating    float64            `json:"rating,omitempty"`
+	Year      int32              `json:"year,omitempty"`
+	Season    oapi.ReleaseSeason `json:"season,omitempty"`
+	Timestamp time.Time          `json:"timestamp"`
+}
+
+// Publisher — потокобезопасный публикатор с пулом каналов.
+type Publisher struct {
+	conn *amqp.Connection
+	pool *sync.Pool
+}
+
+// NewPublisher создаёт новый Publisher.
+// conn должен быть уже установленным и healthy.
+// Рекомендуется передавать durable connection с reconnect-логикой.
+func NewPublisher(conn *amqp.Connection) *Publisher {
+	return &Publisher{
+		conn: conn,
+		pool: &sync.Pool{
+			New: func() any {
+				ch, err := conn.Channel()
+				if err != nil {
+					// Паника уместна: невозможность открыть канал — критическая ошибка инициализации
+					panic(fmt.Errorf("rmqpool: failed to create channel: %w", err))
+				}
+				return ch
+			},
+		},
+	}
+}
+
+// Publish публикует сообщение в указанную очередь.
+// Очередь объявляется как durable (если не существует).
+// Поддерживает context для отмены/таймаута.
+func (p *Publisher) Publish(
+	ctx context.Context,
+	queueName string,
+	payload RabbitRequest,
+	opts ...PublishOption,
+) error {
+	// Применяем опции
+	options := &publishOptions{
+		contentType:  "application/json",
+		deliveryMode: amqp.Persistent,
+		timestamp:    time.Now(),
+	}
+	for _, opt := range opts {
+		opt(options)
+	}
+
+	// Сериализуем payload
+	body, err := json.Marshal(payload)
+	if err != nil {
+		return fmt.Errorf("rmqpool: failed to marshal payload: %w", err)
+	}
+
+	// Берём канал из пула
+	ch := p.getChannel()
+	if ch == nil {
+		return fmt.Errorf("rmqpool: channel is nil (connection may be closed)")
+	}
+	defer p.returnChannel(ch)
+
+	// Объявляем очередь (idempotent)
+	q, err := ch.QueueDeclare(
+		queueName,
+		true,  // durable
+		false, // auto-delete
+		false, // exclusive
+		false, // no-wait
+		nil,   // args
+	)
+	if err != nil {
+		return fmt.Errorf("rmqpool: failed to declare queue %q: %w", queueName, err)
+	}
+
+	// Подготавливаем сообщение
+	msg := amqp.Publishing{
+		DeliveryMode: options.deliveryMode,
+		ContentType:  options.contentType,
+		Timestamp:    options.timestamp,
+		Body:         body,
+	}
+
+	// Публикуем с учётом контекста
+	done := make(chan error, 1)
+	go func() {
+		err := ch.Publish(
+			"",     // exchange (default)
+			q.Name, // routing key
+			false,  // mandatory
+			false,  // immediate
+			msg,
+		)
+		done <- err
+	}()
+
+	select {
+	case err := <-done:
+		return err
+	case <-ctx.Done():
+		return ctx.Err()
+	}
+}
+
+func (p *Publisher) getChannel() *amqp.Channel {
+	raw := p.pool.Get()
+	if raw == nil {
+		ch, _ := p.conn.Channel()
+		return ch
+	}
+	ch := raw.(*amqp.Channel)
+	if ch.IsClosed() { // ← теперь есть!
+		ch.Close() // освободить ресурсы
+		ch, _ = p.conn.Channel()
+	}
+	return ch
+}
+
+// returnChannel возвращает канал в пул, если он жив.
+func (p *Publisher) returnChannel(ch *amqp.Channel) {
+	if ch != nil && !ch.IsClosed() {
+		p.pool.Put(ch)
+	}
+}
+
+// PublishOption позволяет кастомизировать публикацию.
+type PublishOption func(*publishOptions)
+
+type publishOptions struct {
+	contentType  string
+	deliveryMode uint8
+	timestamp    time.Time
+}
+
+// WithContentType устанавливает Content-Type (по умолчанию "application/json").
+func WithContentType(ct string) PublishOption {
+	return func(o *publishOptions) { o.contentType = ct }
+}
+
+// WithTransient делает сообщение transient (не сохраняется на диск).
+// По умолчанию — Persistent.
+func WithTransient() PublishOption {
+	return func(o *publishOptions) { o.deliveryMode = amqp.Transient }
+}
+
+// WithTimestamp устанавливает кастомную метку времени.
+func WithTimestamp(ts time.Time) PublishOption {
+	return func(o *publishOptions) { o.timestamp = ts }
+}
+
+type RPCClient struct {
+	conn    *amqp.Connection
+	timeout time.Duration
+}
+
+func NewRPCClient(conn *amqp.Connection, timeout time.Duration) *RPCClient {
+	return &RPCClient{conn: conn, timeout: timeout}
+}
+
+// Call отправляет запрос в очередь и ждёт ответа.
+// replyPayload — указатель на структуру, в которую раскодировать ответ (например, &MediaResponse{}).
+func (c *RPCClient) Call(
+	ctx context.Context,
+	requestQueue string,
+	request RabbitRequest,
+	replyPayload any,
+) error {
+	// 1. Создаём временный канал (не из пула!)
+	ch, err := c.conn.Channel()
+	if err != nil {
+		return fmt.Errorf("channel: %w", err)
+	}
+	defer ch.Close()
+
+	// 2. Создаём временную очередь для ответов
+	q, err := ch.QueueDeclare(
+		"",    // auto name
+		false, // not durable
+		true,  // exclusive
+		true,  // auto-delete
+		false,
+		nil,
+	)
+	if err != nil {
+		return fmt.Errorf("reply queue: %w", err)
+	}
+
+	// 3. Подписываемся на ответы
+	msgs, err := ch.Consume(
+		q.Name,
+		"",
+		true, // auto-ack
+		true, // exclusive
+		false,
+		false,
+		nil,
+	)
+	if err != nil {
+		return fmt.Errorf("consume: %w", err)
+	}
+
+	// 4. Готовим correlation ID
+	corrID := time.Now().UnixNano()
+
+	// 5. Сериализуем запрос
+	body, err := json.Marshal(request)
+	if err != nil {
+		return fmt.Errorf("marshal request: %w", err)
+	}
+
+	// 6. Публикуем запрос
+	err = ch.Publish(
+		"",
+		requestQueue,
+		false,
+		false,
+		amqp.Publishing{
+			ContentType:   "application/json",
+			CorrelationId: fmt.Sprintf("%d", corrID),
+			ReplyTo:       q.Name,
+			Timestamp:     time.Now(),
+			Body:          body,
+		},
+	)
+	if err != nil {
+		return fmt.Errorf("publish: %w", err)
+	}
+
+	// 7. Ждём ответ с таймаутом
+	ctx, cancel := context.WithTimeout(ctx, c.timeout)
+	defer cancel()
+
+	for {
+		select {
+		case msg := <-msgs:
+			if msg.CorrelationId == fmt.Sprintf("%d", corrID) {
+				return json.Unmarshal(msg.Body, replyPayload)
+			}
+			// игнорируем другие сообщения (маловероятно, но возможно)
+		case <-ctx.Done():
+			return ctx.Err() // timeout or cancelled
+		}
+	}
+}

modules/backend/types.go

@@ -1,12 +1,11 @@
 package main
 
 type Config struct {
-	Mode     string
-	LogLevel string `toml:"LogLevel" env:"LOG_LEVEL"`
-}
-
-type Item struct {
-	ID          int    `json:"id"`
-	Title       string `json:"title"`
-	Description string `json:"description"`
+	Mode           string
+	ServiceAddress string `toml:"ServiceAddress" env:"SERVICE_ADDRESS"`
+	DdUrl          string `toml:"DbUrl" env:"DATABASE_URL"`
+	JwtPrivateKey  string `toml:"JwtPrivateKey" env:"JWT_PRIVATE_KEY"`
+	LogLevel       string `toml:"LogLevel" env:"LOG_LEVEL"`
+	RmqURL         string `toml:"RabbitMQUrl" env:"RABBITMQ_URL"`
+	AuthEnabled    string `toml:"AuthEnabled" env:"AUTH_ENABLED"`
 }

modules/frontend/nginx-default.conf

@@ -19,6 +19,15 @@ server {
         proxy_set_header Host $host;
         proxy_cache_bypass $http_upgrade;
     }
+    location /auth/ {
+        rewrite ^/auth/(.*)$ /$1 break;
+        proxy_pass http://nyanimedb-auth:8082/;
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection 'upgrade';
+        proxy_set_header Host $host;
+        proxy_cache_bypass $http_upgrade;
+    }
     #error_page  404              /404.html;
 
     error_page   500 502 503 504  /50x.html;

modules/frontend/package.json

@@ -10,10 +10,15 @@
     "preview": "vite preview"
   },
   "dependencies": {
+    "@headlessui/react": "^2.2.9",
+    "@heroicons/react": "^2.2.0",
+    "@tailwindcss/vite": "^4.1.17",
     "axios": "^1.12.2",
     "react": "^19.1.1",
+    "react-cookie": "^8.0.1",
     "react-dom": "^19.1.1",
-    "react-router-dom": "^7.9.4"
+    "react-router-dom": "^7.9.4",
+    "tailwindcss": "^4.1.17"
   },
   "devDependencies": {
     "@eslint/js": "^9.36.0",
@@ -29,5 +34,8 @@
     "typescript": "~5.9.3",
     "typescript-eslint": "^8.45.0",
     "vite": "^7.1.7"
+  },
+  "engines": {
+    "node": "20.x"
   }
 }

modules/frontend/src/App.css

@@ -1,42 +0,0 @@
-#root {
-  max-width: 1280px;
-  margin: 0 auto;
-  padding: 2rem;
-  text-align: center;
-}
-
-.logo {
-  height: 6em;
-  padding: 1.5em;
-  will-change: filter;
-  transition: filter 300ms;
-}
-.logo:hover {
-  filter: drop-shadow(0 0 2em #646cffaa);
-}
-.logo.react:hover {
-  filter: drop-shadow(0 0 2em #61dafbaa);
-}
-
-@keyframes logo-spin {
-  from {
-    transform: rotate(0deg);
-  }
-  to {
-    transform: rotate(360deg);
-  }
-}
-
-@media (prefers-reduced-motion: no-preference) {
-  a:nth-of-type(2) .logo {
-    animation: logo-spin infinite 20s linear;
-  }
-}
-
-.card {
-  padding: 2em;
-}
-
-.read-the-docs {
-  color: #888;
-}

modules/frontend/src/App.tsx

@@ -1,15 +1,43 @@
 import React from "react";
 import { BrowserRouter as Router, Routes, Route } from "react-router-dom";
-import UserPage from "./components/UserPage/UserPage";
+import UserPage from "./pages/UserPage/UserPage";
+import TitlesPage from "./pages/TitlesPage/TitlesPage";
+import TitlePage from "./pages/TitlePage/TitlePage";
+import { LoginPage } from "./pages/LoginPage/LoginPage";
+import { Header } from "./components/Header/Header";
+
+// import { OpenAPI } from "./api";
+
+// OpenAPI.WITH_CREDENTIALS = true
 
 const App: React.FC = () => {
+  const username = localStorage.getItem("username") || undefined;
+  const userId = localStorage.getItem("userId");
+
   return (
     <Router>
+      <Header username={username} />
       <Routes>
+        {/* auth */}
+        <Route path="/login" element={<LoginPage />} />
+        <Route path="/signup" element={<LoginPage />} />
+        {/*<Route path="/signup" element={<LoginPage />} />*/}
+        
+        {/* users */}
+        {/*<Route path="/users" element={<UsersPage />} />*/}
         <Route path="/users/:id" element={<UserPage />} />
+        <Route
+          path="/profile"
+          element={userId ? <UserPage userId={userId} /> : <LoginPage />}
+        />
+
+        {/* titles */}
+        <Route path="/titles" element={<TitlesPage />} />
+        <Route path="/titles/:id" element={<TitlePage />} />
       </Routes>
     </Router>
   );
 };
 
+
 export default App;

modules/frontend/src/api/client.gen.ts

@@ -0,0 +1,16 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import { type ClientOptions, type Config, createClient, createConfig } from './client';
+import type { ClientOptions as ClientOptions2 } from './types.gen';
+
+/**
+ * The `createClientConfig()` function will be called on client initialization
+ * and the returned object will become the client's initial configuration.
+ *
+ * You may want to initialize your client this way instead of calling
+ * `setConfig()`. This is useful for example if you're using Next.js
+ * to ensure your client always has the correct values.
+ */
+export type CreateClientConfig<T extends ClientOptions = ClientOptions2> = (override?: Config<ClientOptions & T>) => Config<Required<ClientOptions> & T>;
+
+export const client = createClient(createConfig<ClientOptions2>({ baseUrl: 'http://10.1.0.65:8081/api/v1' }));

modules/frontend/src/api/client/client.gen.ts

@@ -0,0 +1,301 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import { createSseClient } from '../core/serverSentEvents.gen';
+import type { HttpMethod } from '../core/types.gen';
+import { getValidRequestBody } from '../core/utils.gen';
+import type {
+  Client,
+  Config,
+  RequestOptions,
+  ResolvedRequestOptions,
+} from './types.gen';
+import {
+  buildUrl,
+  createConfig,
+  createInterceptors,
+  getParseAs,
+  mergeConfigs,
+  mergeHeaders,
+  setAuthParams,
+} from './utils.gen';
+
+type ReqInit = Omit<RequestInit, 'body' | 'headers'> & {
+  body?: any;
+  headers: ReturnType<typeof mergeHeaders>;
+};
+
+export const createClient = (config: Config = {}): Client => {
+  let _config = mergeConfigs(createConfig(), config);
+
+  const getConfig = (): Config => ({ ..._config });
+
+  const setConfig = (config: Config): Config => {
+    _config = mergeConfigs(_config, config);
+    return getConfig();
+  };
+
+  const interceptors = createInterceptors<
+    Request,
+    Response,
+    unknown,
+    ResolvedRequestOptions
+  >();
+
+  const beforeRequest = async (options: RequestOptions) => {
+    const opts = {
+      ..._config,
+      ...options,
+      fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+      headers: mergeHeaders(_config.headers, options.headers),
+      serializedBody: undefined,
+    };
+
+    if (opts.security) {
+      await setAuthParams({
+        ...opts,
+        security: opts.security,
+      });
+    }
+
+    if (opts.requestValidator) {
+      await opts.requestValidator(opts);
+    }
+
+    if (opts.body !== undefined && opts.bodySerializer) {
+      opts.serializedBody = opts.bodySerializer(opts.body);
+    }
+
+    // remove Content-Type header if body is empty to avoid sending invalid requests
+    if (opts.body === undefined || opts.serializedBody === '') {
+      opts.headers.delete('Content-Type');
+    }
+
+    const url = buildUrl(opts);
+
+    return { opts, url };
+  };
+
+  const request: Client['request'] = async (options) => {
+    // @ts-expect-error
+    const { opts, url } = await beforeRequest(options);
+    const requestInit: ReqInit = {
+      redirect: 'follow',
+      ...opts,
+      body: getValidRequestBody(opts),
+    };
+
+    let request = new Request(url, requestInit);
+
+    for (const fn of interceptors.request.fns) {
+      if (fn) {
+        request = await fn(request, opts);
+      }
+    }
+
+    // fetch must be assigned here, otherwise it would throw the error:
+    // TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation
+    const _fetch = opts.fetch!;
+    let response: Response;
+
+    try {
+      response = await _fetch(request);
+    } catch (error) {
+      // Handle fetch exceptions (AbortError, network errors, etc.)
+      let finalError = error;
+
+      for (const fn of interceptors.error.fns) {
+        if (fn) {
+          finalError = (await fn(
+            error,
+            undefined as any,
+            request,
+            opts,
+          )) as unknown;
+        }
+      }
+
+      finalError = finalError || ({} as unknown);
+
+      if (opts.throwOnError) {
+        throw finalError;
+      }
+
+      // Return error response
+      return opts.responseStyle === 'data'
+        ? undefined
+        : {
+            error: finalError,
+            request,
+            response: undefined as any,
+          };
+    }
+
+    for (const fn of interceptors.response.fns) {
+      if (fn) {
+        response = await fn(response, request, opts);
+      }
+    }
+
+    const result = {
+      request,
+      response,
+    };
+
+    if (response.ok) {
+      const parseAs =
+        (opts.parseAs === 'auto'
+          ? getParseAs(response.headers.get('Content-Type'))
+          : opts.parseAs) ?? 'json';
+
+      if (
+        response.status === 204 ||
+        response.headers.get('Content-Length') === '0'
+      ) {
+        let emptyData: any;
+        switch (parseAs) {
+          case 'arrayBuffer':
+          case 'blob':
+          case 'text':
+            emptyData = await response[parseAs]();
+            break;
+          case 'formData':
+            emptyData = new FormData();
+            break;
+          case 'stream':
+            emptyData = response.body;
+            break;
+          case 'json':
+          default:
+            emptyData = {};
+            break;
+        }
+        return opts.responseStyle === 'data'
+          ? emptyData
+          : {
+              data: emptyData,
+              ...result,
+            };
+      }
+
+      let data: any;
+      switch (parseAs) {
+        case 'arrayBuffer':
+        case 'blob':
+        case 'formData':
+        case 'json':
+        case 'text':
+          data = await response[parseAs]();
+          break;
+        case 'stream':
+          return opts.responseStyle === 'data'
+            ? response.body
+            : {
+                data: response.body,
+                ...result,
+              };
+      }
+
+      if (parseAs === 'json') {
+        if (opts.responseValidator) {
+          await opts.responseValidator(data);
+        }
+
+        if (opts.responseTransformer) {
+          data = await opts.responseTransformer(data);
+        }
+      }
+
+      return opts.responseStyle === 'data'
+        ? data
+        : {
+            data,
+            ...result,
+          };
+    }
+
+    const textError = await response.text();
+    let jsonError: unknown;
+
+    try {
+      jsonError = JSON.parse(textError);
+    } catch {
+      // noop
+    }
+
+    const error = jsonError ?? textError;
+    let finalError = error;
+
+    for (const fn of interceptors.error.fns) {
+      if (fn) {
+        finalError = (await fn(error, response, request, opts)) as string;
+      }
+    }
+
+    finalError = finalError || ({} as string);
+
+    if (opts.throwOnError) {
+      throw finalError;
+    }
+
+    // TODO: we probably want to return error and improve types
+    return opts.responseStyle === 'data'
+      ? undefined
+      : {
+          error: finalError,
+          ...result,
+        };
+  };
+
+  const makeMethodFn =
+    (method: Uppercase<HttpMethod>) => (options: RequestOptions) =>
+      request({ ...options, method });
+
+  const makeSseFn =
+    (method: Uppercase<HttpMethod>) => async (options: RequestOptions) => {
+      const { opts, url } = await beforeRequest(options);
+      return createSseClient({
+        ...opts,
+        body: opts.body as BodyInit | null | undefined,
+        headers: opts.headers as unknown as Record<string, string>,
+        method,
+        onRequest: async (url, init) => {
+          let request = new Request(url, init);
+          for (const fn of interceptors.request.fns) {
+            if (fn) {
+              request = await fn(request, opts);
+            }
+          }
+          return request;
+        },
+        url,
+      });
+    };
+
+  return {
+    buildUrl,
+    connect: makeMethodFn('CONNECT'),
+    delete: makeMethodFn('DELETE'),
+    get: makeMethodFn('GET'),
+    getConfig,
+    head: makeMethodFn('HEAD'),
+    interceptors,
+    options: makeMethodFn('OPTIONS'),
+    patch: makeMethodFn('PATCH'),
+    post: makeMethodFn('POST'),
+    put: makeMethodFn('PUT'),
+    request,
+    setConfig,
+    sse: {
+      connect: makeSseFn('CONNECT'),
+      delete: makeSseFn('DELETE'),
+      get: makeSseFn('GET'),
+      head: makeSseFn('HEAD'),
+      options: makeSseFn('OPTIONS'),
+      patch: makeSseFn('PATCH'),
+      post: makeSseFn('POST'),
+      put: makeSseFn('PUT'),
+      trace: makeSseFn('TRACE'),
+    },
+    trace: makeMethodFn('TRACE'),
+  } as Client;
+};

modules/frontend/src/api/client/index.ts

@@ -0,0 +1,25 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+export type { Auth } from '../core/auth.gen';
+export type { QuerySerializerOptions } from '../core/bodySerializer.gen';
+export {
+  formDataBodySerializer,
+  jsonBodySerializer,
+  urlSearchParamsBodySerializer,
+} from '../core/bodySerializer.gen';
+export { buildClientParams } from '../core/params.gen';
+export { serializeQueryKeyValue } from '../core/queryKeySerializer.gen';
+export { createClient } from './client.gen';
+export type {
+  Client,
+  ClientOptions,
+  Config,
+  CreateClientConfig,
+  Options,
+  RequestOptions,
+  RequestResult,
+  ResolvedRequestOptions,
+  ResponseStyle,
+  TDataShape,
+} from './types.gen';
+export { createConfig, mergeHeaders } from './utils.gen';

modules/frontend/src/api/client/types.gen.ts

@@ -0,0 +1,241 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import type { Auth } from '../core/auth.gen';
+import type {
+  ServerSentEventsOptions,
+  ServerSentEventsResult,
+} from '../core/serverSentEvents.gen';
+import type {
+  Client as CoreClient,
+  Config as CoreConfig,
+} from '../core/types.gen';
+import type { Middleware } from './utils.gen';
+
+export type ResponseStyle = 'data' | 'fields';
+
+export interface Config<T extends ClientOptions = ClientOptions>
+  extends Omit<RequestInit, 'body' | 'headers' | 'method'>,
+    CoreConfig {
+  /**
+   * Base URL for all requests made by this client.
+   */
+  baseUrl?: T['baseUrl'];
+  /**
+   * Fetch API implementation. You can use this option to provide a custom
+   * fetch instance.
+   *
+   * @default globalThis.fetch
+   */
+  fetch?: typeof fetch;
+  /**
+   * Please don't use the Fetch client for Next.js applications. The `next`
+   * options won't have any effect.
+   *
+   * Install {@link https://www.npmjs.com/package/@hey-api/client-next `@hey-api/client-next`} instead.
+   */
+  next?: never;
+  /**
+   * Return the response data parsed in a specified format. By default, `auto`
+   * will infer the appropriate method from the `Content-Type` response header.
+   * You can override this behavior with any of the {@link Body} methods.
+   * Select `stream` if you don't want to parse response data at all.
+   *
+   * @default 'auto'
+   */
+  parseAs?:
+    | 'arrayBuffer'
+    | 'auto'
+    | 'blob'
+    | 'formData'
+    | 'json'
+    | 'stream'
+    | 'text';
+  /**
+   * Should we return only data or multiple fields (data, error, response, etc.)?
+   *
+   * @default 'fields'
+   */
+  responseStyle?: ResponseStyle;
+  /**
+   * Throw an error instead of returning it in the response?
+   *
+   * @default false
+   */
+  throwOnError?: T['throwOnError'];
+}
+
+export interface RequestOptions<
+  TData = unknown,
+  TResponseStyle extends ResponseStyle = 'fields',
+  ThrowOnError extends boolean = boolean,
+  Url extends string = string,
+> extends Config<{
+      responseStyle: TResponseStyle;
+      throwOnError: ThrowOnError;
+    }>,
+    Pick<
+      ServerSentEventsOptions<TData>,
+      | 'onSseError'
+      | 'onSseEvent'
+      | 'sseDefaultRetryDelay'
+      | 'sseMaxRetryAttempts'
+      | 'sseMaxRetryDelay'
+    > {
+  /**
+   * Any body that you want to add to your request.
+   *
+   * {@link https://developer.mozilla.org/docs/Web/API/fetch#body}
+   */
+  body?: unknown;
+  path?: Record<string, unknown>;
+  query?: Record<string, unknown>;
+  /**
+   * Security mechanism(s) to use for the request.
+   */
+  security?: ReadonlyArray<Auth>;
+  url: Url;
+}
+
+export interface ResolvedRequestOptions<
+  TResponseStyle extends ResponseStyle = 'fields',
+  ThrowOnError extends boolean = boolean,
+  Url extends string = string,
+> extends RequestOptions<unknown, TResponseStyle, ThrowOnError, Url> {
+  serializedBody?: string;
+}
+
+export type RequestResult<
+  TData = unknown,
+  TError = unknown,
+  ThrowOnError extends boolean = boolean,
+  TResponseStyle extends ResponseStyle = 'fields',
+> = ThrowOnError extends true
+  ? Promise<
+      TResponseStyle extends 'data'
+        ? TData extends Record<string, unknown>
+          ? TData[keyof TData]
+          : TData
+        : {
+            data: TData extends Record<string, unknown>
+              ? TData[keyof TData]
+              : TData;
+            request: Request;
+            response: Response;
+          }
+    >
+  : Promise<
+      TResponseStyle extends 'data'
+        ?
+            | (TData extends Record<string, unknown>
+                ? TData[keyof TData]
+                : TData)
+            | undefined
+        : (
+            | {
+                data: TData extends Record<string, unknown>
+                  ? TData[keyof TData]
+                  : TData;
+                error: undefined;
+              }
+            | {
+                data: undefined;
+                error: TError extends Record<string, unknown>
+                  ? TError[keyof TError]
+                  : TError;
+              }
+          ) & {
+            request: Request;
+            response: Response;
+          }
+    >;
+
+export interface ClientOptions {
+  baseUrl?: string;
+  responseStyle?: ResponseStyle;
+  throwOnError?: boolean;
+}
+
+type MethodFn = <
+  TData = unknown,
+  TError = unknown,
+  ThrowOnError extends boolean = false,
+  TResponseStyle extends ResponseStyle = 'fields',
+>(
+  options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>,
+) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+
+type SseFn = <
+  TData = unknown,
+  TError = unknown,
+  ThrowOnError extends boolean = false,
+  TResponseStyle extends ResponseStyle = 'fields',
+>(
+  options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>,
+) => Promise<ServerSentEventsResult<TData, TError>>;
+
+type RequestFn = <
+  TData = unknown,
+  TError = unknown,
+  ThrowOnError extends boolean = false,
+  TResponseStyle extends ResponseStyle = 'fields',
+>(
+  options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'> &
+    Pick<
+      Required<RequestOptions<TData, TResponseStyle, ThrowOnError>>,
+      'method'
+    >,
+) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+
+type BuildUrlFn = <
+  TData extends {
+    body?: unknown;
+    path?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    url: string;
+  },
+>(
+  options: TData & Options<TData>,
+) => string;
+
+export type Client = CoreClient<
+  RequestFn,
+  Config,
+  MethodFn,
+  BuildUrlFn,
+  SseFn
+> & {
+  interceptors: Middleware<Request, Response, unknown, ResolvedRequestOptions>;
+};
+
+/**
+ * The `createClientConfig()` function will be called on client initialization
+ * and the returned object will become the client's initial configuration.
+ *
+ * You may want to initialize your client this way instead of calling
+ * `setConfig()`. This is useful for example if you're using Next.js
+ * to ensure your client always has the correct values.
+ */
+export type CreateClientConfig<T extends ClientOptions = ClientOptions> = (
+  override?: Config<ClientOptions & T>,
+) => Config<Required<ClientOptions> & T>;
+
+export interface TDataShape {
+  body?: unknown;
+  headers?: unknown;
+  path?: unknown;
+  query?: unknown;
+  url: string;
+}
+
+type OmitKeys<T, K> = Pick<T, Exclude<keyof T, K>>;
+
+export type Options<
+  TData extends TDataShape = TDataShape,
+  ThrowOnError extends boolean = boolean,
+  TResponse = unknown,
+  TResponseStyle extends ResponseStyle = 'fields',
+> = OmitKeys<
+  RequestOptions<TResponse, TResponseStyle, ThrowOnError>,
+  'body' | 'path' | 'query' | 'url'
+> &
+  ([TData] extends [never] ? unknown : Omit<TData, 'url'>);

modules/frontend/src/api/client/utils.gen.ts

@@ -0,0 +1,332 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import { getAuthToken } from '../core/auth.gen';
+import type { QuerySerializerOptions } from '../core/bodySerializer.gen';
+import { jsonBodySerializer } from '../core/bodySerializer.gen';
+import {
+  serializeArrayParam,
+  serializeObjectParam,
+  serializePrimitiveParam,
+} from '../core/pathSerializer.gen';
+import { getUrl } from '../core/utils.gen';
+import type { Client, ClientOptions, Config, RequestOptions } from './types.gen';
+
+export const createQuerySerializer = <T = unknown>({
+  parameters = {},
+  ...args
+}: QuerySerializerOptions = {}) => {
+  const querySerializer = (queryParams: T) => {
+    const search: string[] = [];
+    if (queryParams && typeof queryParams === 'object') {
+      for (const name in queryParams) {
+        const value = queryParams[name];
+
+        if (value === undefined || value === null) {
+          continue;
+        }
+
+        const options = parameters[name] || args;
+
+        if (Array.isArray(value)) {
+          const serializedArray = serializeArrayParam({
+            allowReserved: options.allowReserved,
+            explode: true,
+            name,
+            style: 'form',
+            value,
+            ...options.array,
+          });
+          if (serializedArray) search.push(serializedArray);
+        } else if (typeof value === 'object') {
+          const serializedObject = serializeObjectParam({
+            allowReserved: options.allowReserved,
+            explode: true,
+            name,
+            style: 'deepObject',
+            value: value as Record<string, unknown>,
+            ...options.object,
+          });
+          if (serializedObject) search.push(serializedObject);
+        } else {
+          const serializedPrimitive = serializePrimitiveParam({
+            allowReserved: options.allowReserved,
+            name,
+            value: value as string,
+          });
+          if (serializedPrimitive) search.push(serializedPrimitive);
+        }
+      }
+    }
+    return search.join('&');
+  };
+  return querySerializer;
+};
+
+/**
+ * Infers parseAs value from provided Content-Type header.
+ */
+export const getParseAs = (
+  contentType: string | null,
+): Exclude<Config['parseAs'], 'auto'> => {
+  if (!contentType) {
+    // If no Content-Type header is provided, the best we can do is return the raw response body,
+    // which is effectively the same as the 'stream' option.
+    return 'stream';
+  }
+
+  const cleanContent = contentType.split(';')[0]?.trim();
+
+  if (!cleanContent) {
+    return;
+  }
+
+  if (
+    cleanContent.startsWith('application/json') ||
+    cleanContent.endsWith('+json')
+  ) {
+    return 'json';
+  }
+
+  if (cleanContent === 'multipart/form-data') {
+    return 'formData';
+  }
+
+  if (
+    ['application/', 'audio/', 'image/', 'video/'].some((type) =>
+      cleanContent.startsWith(type),
+    )
+  ) {
+    return 'blob';
+  }
+
+  if (cleanContent.startsWith('text/')) {
+    return 'text';
+  }
+
+  return;
+};
+
+const checkForExistence = (
+  options: Pick<RequestOptions, 'auth' | 'query'> & {
+    headers: Headers;
+  },
+  name?: string,
+): boolean => {
+  if (!name) {
+    return false;
+  }
+  if (
+    options.headers.has(name) ||
+    options.query?.[name] ||
+    options.headers.get('Cookie')?.includes(`${name}=`)
+  ) {
+    return true;
+  }
+  return false;
+};
+
+export const setAuthParams = async ({
+  security,
+  ...options
+}: Pick<Required<RequestOptions>, 'security'> &
+  Pick<RequestOptions, 'auth' | 'query'> & {
+    headers: Headers;
+  }) => {
+  for (const auth of security) {
+    if (checkForExistence(options, auth.name)) {
+      continue;
+    }
+
+    const token = await getAuthToken(auth, options.auth);
+
+    if (!token) {
+      continue;
+    }
+
+    const name = auth.name ?? 'Authorization';
+
+    switch (auth.in) {
+      case 'query':
+        if (!options.query) {
+          options.query = {};
+        }
+        options.query[name] = token;
+        break;
+      case 'cookie':
+        options.headers.append('Cookie', `${name}=${token}`);
+        break;
+      case 'header':
+      default:
+        options.headers.set(name, token);
+        break;
+    }
+  }
+};
+
+export const buildUrl: Client['buildUrl'] = (options) =>
+  getUrl({
+    baseUrl: options.baseUrl as string,
+    path: options.path,
+    query: options.query,
+    querySerializer:
+      typeof options.querySerializer === 'function'
+        ? options.querySerializer
+        : createQuerySerializer(options.querySerializer),
+    url: options.url,
+  });
+
+export const mergeConfigs = (a: Config, b: Config): Config => {
+  const config = { ...a, ...b };
+  if (config.baseUrl?.endsWith('/')) {
+    config.baseUrl = config.baseUrl.substring(0, config.baseUrl.length - 1);
+  }
+  config.headers = mergeHeaders(a.headers, b.headers);
+  return config;
+};
+
+const headersEntries = (headers: Headers): Array<[string, string]> => {
+  const entries: Array<[string, string]> = [];
+  headers.forEach((value, key) => {
+    entries.push([key, value]);
+  });
+  return entries;
+};
+
+export const mergeHeaders = (
+  ...headers: Array<Required<Config>['headers'] | undefined>
+): Headers => {
+  const mergedHeaders = new Headers();
+  for (const header of headers) {
+    if (!header) {
+      continue;
+    }
+
+    const iterator =
+      header instanceof Headers
+        ? headersEntries(header)
+        : Object.entries(header);
+
+    for (const [key, value] of iterator) {
+      if (value === null) {
+        mergedHeaders.delete(key);
+      } else if (Array.isArray(value)) {
+        for (const v of value) {
+          mergedHeaders.append(key, v as string);
+        }
+      } else if (value !== undefined) {
+        // assume object headers are meant to be JSON stringified, i.e. their
+        // content value in OpenAPI specification is 'application/json'
+        mergedHeaders.set(
+          key,
+          typeof value === 'object' ? JSON.stringify(value) : (value as string),
+        );
+      }
+    }
+  }
+  return mergedHeaders;
+};
+
+type ErrInterceptor<Err, Res, Req, Options> = (
+  error: Err,
+  response: Res,
+  request: Req,
+  options: Options,
+) => Err | Promise<Err>;
+
+type ReqInterceptor<Req, Options> = (
+  request: Req,
+  options: Options,
+) => Req | Promise<Req>;
+
+type ResInterceptor<Res, Req, Options> = (
+  response: Res,
+  request: Req,
+  options: Options,
+) => Res | Promise<Res>;
+
+class Interceptors<Interceptor> {
+  fns: Array<Interceptor | null> = [];
+
+  clear(): void {
+    this.fns = [];
+  }
+
+  eject(id: number | Interceptor): void {
+    const index = this.getInterceptorIndex(id);
+    if (this.fns[index]) {
+      this.fns[index] = null;
+    }
+  }
+
+  exists(id: number | Interceptor): boolean {
+    const index = this.getInterceptorIndex(id);
+    return Boolean(this.fns[index]);
+  }
+
+  getInterceptorIndex(id: number | Interceptor): number {
+    if (typeof id === 'number') {
+      return this.fns[id] ? id : -1;
+    }
+    return this.fns.indexOf(id);
+  }
+
+  update(
+    id: number | Interceptor,
+    fn: Interceptor,
+  ): number | Interceptor | false {
+    const index = this.getInterceptorIndex(id);
+    if (this.fns[index]) {
+      this.fns[index] = fn;
+      return id;
+    }
+    return false;
+  }
+
+  use(fn: Interceptor): number {
+    this.fns.push(fn);
+    return this.fns.length - 1;
+  }
+}
+
+export interface Middleware<Req, Res, Err, Options> {
+  error: Interceptors<ErrInterceptor<Err, Res, Req, Options>>;
+  request: Interceptors<ReqInterceptor<Req, Options>>;
+  response: Interceptors<ResInterceptor<Res, Req, Options>>;
+}
+
+export const createInterceptors = <Req, Res, Err, Options>(): Middleware<
+  Req,
+  Res,
+  Err,
+  Options
+> => ({
+  error: new Interceptors<ErrInterceptor<Err, Res, Req, Options>>(),
+  request: new Interceptors<ReqInterceptor<Req, Options>>(),
+  response: new Interceptors<ResInterceptor<Res, Req, Options>>(),
+});
+
+const defaultQuerySerializer = createQuerySerializer({
+  allowReserved: false,
+  array: {
+    explode: true,
+    style: 'form',
+  },
+  object: {
+    explode: true,
+    style: 'deepObject',
+  },
+});
+
+const defaultHeaders = {
+  'Content-Type': 'application/json',
+};
+
+export const createConfig = <T extends ClientOptions = ClientOptions>(
+  override: Config<Omit<ClientOptions, keyof T> & T> = {},
+): Config<Omit<ClientOptions, keyof T> & T> => ({
+  ...jsonBodySerializer,
+  headers: defaultHeaders,
+  parseAs: 'auto',
+  querySerializer: defaultQuerySerializer,
+  ...override,
+});

modules/frontend/src/api/core/auth.gen.ts

@@ -0,0 +1,42 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+export type AuthToken = string | undefined;
+
+export interface Auth {
+  /**
+   * Which part of the request do we use to send the auth?
+   *
+   * @default 'header'
+   */
+  in?: 'header' | 'query' | 'cookie';
+  /**
+   * Header or query parameter name.
+   *
+   * @default 'Authorization'
+   */
+  name?: string;
+  scheme?: 'basic' | 'bearer';
+  type: 'apiKey' | 'http';
+}
+
+export const getAuthToken = async (
+  auth: Auth,
+  callback: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken,
+): Promise<string | undefined> => {
+  const token =
+    typeof callback === 'function' ? await callback(auth) : callback;
+
+  if (!token) {
+    return;
+  }
+
+  if (auth.scheme === 'bearer') {
+    return `Bearer ${token}`;
+  }
+
+  if (auth.scheme === 'basic') {
+    return `Basic ${btoa(token)}`;
+  }
+
+  return token;
+};

modules/frontend/src/api/core/bodySerializer.gen.ts

@@ -0,0 +1,100 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import type {
+  ArrayStyle,
+  ObjectStyle,
+  SerializerOptions,
+} from './pathSerializer.gen';
+
+export type QuerySerializer = (query: Record<string, unknown>) => string;
+
+export type BodySerializer = (body: any) => any;
+
+type QuerySerializerOptionsObject = {
+  allowReserved?: boolean;
+  array?: Partial<SerializerOptions<ArrayStyle>>;
+  object?: Partial<SerializerOptions<ObjectStyle>>;
+};
+
+export type QuerySerializerOptions = QuerySerializerOptionsObject & {
+  /**
+   * Per-parameter serialization overrides. When provided, these settings
+   * override the global array/object settings for specific parameter names.
+   */
+  parameters?: Record<string, QuerySerializerOptionsObject>;
+};
+
+const serializeFormDataPair = (
+  data: FormData,
+  key: string,
+  value: unknown,
+): void => {
+  if (typeof value === 'string' || value instanceof Blob) {
+    data.append(key, value);
+  } else if (value instanceof Date) {
+    data.append(key, value.toISOString());
+  } else {
+    data.append(key, JSON.stringify(value));
+  }
+};
+
+const serializeUrlSearchParamsPair = (
+  data: URLSearchParams,
+  key: string,
+  value: unknown,
+): void => {
+  if (typeof value === 'string') {
+    data.append(key, value);
+  } else {
+    data.append(key, JSON.stringify(value));
+  }
+};
+
+export const formDataBodySerializer = {
+  bodySerializer: <T extends Record<string, any> | Array<Record<string, any>>>(
+    body: T,
+  ): FormData => {
+    const data = new FormData();
+
+    Object.entries(body).forEach(([key, value]) => {
+      if (value === undefined || value === null) {
+        return;
+      }
+      if (Array.isArray(value)) {
+        value.forEach((v) => serializeFormDataPair(data, key, v));
+      } else {
+        serializeFormDataPair(data, key, value);
+      }
+    });
+
+    return data;
+  },
+};
+
+export const jsonBodySerializer = {
+  bodySerializer: <T>(body: T): string =>
+    JSON.stringify(body, (_key, value) =>
+      typeof value === 'bigint' ? value.toString() : value,
+    ),
+};
+
+export const urlSearchParamsBodySerializer = {
+  bodySerializer: <T extends Record<string, any> | Array<Record<string, any>>>(
+    body: T,
+  ): string => {
+    const data = new URLSearchParams();
+
+    Object.entries(body).forEach(([key, value]) => {
+      if (value === undefined || value === null) {
+        return;
+      }
+      if (Array.isArray(value)) {
+        value.forEach((v) => serializeUrlSearchParamsPair(data, key, v));
+      } else {
+        serializeUrlSearchParamsPair(data, key, value);
+      }
+    });
+
+    return data.toString();
+  },
+};

modules/frontend/src/api/core/params.gen.ts

@@ -0,0 +1,176 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+type Slot = 'body' | 'headers' | 'path' | 'query';
+
+export type Field =
+  | {
+      in: Exclude<Slot, 'body'>;
+      /**
+       * Field name. This is the name we want the user to see and use.
+       */
+      key: string;
+      /**
+       * Field mapped name. This is the name we want to use in the request.
+       * If omitted, we use the same value as `key`.
+       */
+      map?: string;
+    }
+  | {
+      in: Extract<Slot, 'body'>;
+      /**
+       * Key isn't required for bodies.
+       */
+      key?: string;
+      map?: string;
+    }
+  | {
+      /**
+       * Field name. This is the name we want the user to see and use.
+       */
+      key: string;
+      /**
+       * Field mapped name. This is the name we want to use in the request.
+       * If `in` is omitted, `map` aliases `key` to the transport layer.
+       */
+      map: Slot;
+    };
+
+export interface Fields {
+  allowExtra?: Partial<Record<Slot, boolean>>;
+  args?: ReadonlyArray<Field>;
+}
+
+export type FieldsConfig = ReadonlyArray<Field | Fields>;
+
+const extraPrefixesMap: Record<string, Slot> = {
+  $body_: 'body',
+  $headers_: 'headers',
+  $path_: 'path',
+  $query_: 'query',
+};
+const extraPrefixes = Object.entries(extraPrefixesMap);
+
+type KeyMap = Map<
+  string,
+  | {
+      in: Slot;
+      map?: string;
+    }
+  | {
+      in?: never;
+      map: Slot;
+    }
+>;
+
+const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
+  if (!map) {
+    map = new Map();
+  }
+
+  for (const config of fields) {
+    if ('in' in config) {
+      if (config.key) {
+        map.set(config.key, {
+          in: config.in,
+          map: config.map,
+        });
+      }
+    } else if ('key' in config) {
+      map.set(config.key, {
+        map: config.map,
+      });
+    } else if (config.args) {
+      buildKeyMap(config.args, map);
+    }
+  }
+
+  return map;
+};
+
+interface Params {
+  body: unknown;
+  headers: Record<string, unknown>;
+  path: Record<string, unknown>;
+  query: Record<string, unknown>;
+}
+
+const stripEmptySlots = (params: Params) => {
+  for (const [slot, value] of Object.entries(params)) {
+    if (value && typeof value === 'object' && !Object.keys(value).length) {
+      delete params[slot as Slot];
+    }
+  }
+};
+
+export const buildClientParams = (
+  args: ReadonlyArray<unknown>,
+  fields: FieldsConfig,
+) => {
+  const params: Params = {
+    body: {},
+    headers: {},
+    path: {},
+    query: {},
+  };
+
+  const map = buildKeyMap(fields);
+
+  let config: FieldsConfig[number] | undefined;
+
+  for (const [index, arg] of args.entries()) {
+    if (fields[index]) {
+      config = fields[index];
+    }
+
+    if (!config) {
+      continue;
+    }
+
+    if ('in' in config) {
+      if (config.key) {
+        const field = map.get(config.key)!;
+        const name = field.map || config.key;
+        if (field.in) {
+          (params[field.in] as Record<string, unknown>)[name] = arg;
+        }
+      } else {
+        params.body = arg;
+      }
+    } else {
+      for (const [key, value] of Object.entries(arg ?? {})) {
+        const field = map.get(key);
+
+        if (field) {
+          if (field.in) {
+            const name = field.map || key;
+            (params[field.in] as Record<string, unknown>)[name] = value;
+          } else {
+            params[field.map] = value;
+          }
+        } else {
+          const extra = extraPrefixes.find(([prefix]) =>
+            key.startsWith(prefix),
+          );
+
+          if (extra) {
+            const [prefix, slot] = extra;
+            (params[slot] as Record<string, unknown>)[
+              key.slice(prefix.length)
+            ] = value;
+          } else if ('allowExtra' in config && config.allowExtra) {
+            for (const [slot, allowed] of Object.entries(config.allowExtra)) {
+              if (allowed) {
+                (params[slot as Slot] as Record<string, unknown>)[key] = value;
+                break;
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  stripEmptySlots(params);
+
+  return params;
+};

modules/frontend/src/api/core/pathSerializer.gen.ts

@@ -0,0 +1,181 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+interface SerializeOptions<T>
+  extends SerializePrimitiveOptions,
+    SerializerOptions<T> {}
+
+interface SerializePrimitiveOptions {
+  allowReserved?: boolean;
+  name: string;
+}
+
+export interface SerializerOptions<T> {
+  /**
+   * @default true
+   */
+  explode: boolean;
+  style: T;
+}
+
+export type ArrayStyle = 'form' | 'spaceDelimited' | 'pipeDelimited';
+export type ArraySeparatorStyle = ArrayStyle | MatrixStyle;
+type MatrixStyle = 'label' | 'matrix' | 'simple';
+export type ObjectStyle = 'form' | 'deepObject';
+type ObjectSeparatorStyle = ObjectStyle | MatrixStyle;
+
+interface SerializePrimitiveParam extends SerializePrimitiveOptions {
+  value: string;
+}
+
+export const separatorArrayExplode = (style: ArraySeparatorStyle) => {
+  switch (style) {
+    case 'label':
+      return '.';
+    case 'matrix':
+      return ';';
+    case 'simple':
+      return ',';
+    default:
+      return '&';
+  }
+};
+
+export const separatorArrayNoExplode = (style: ArraySeparatorStyle) => {
+  switch (style) {
+    case 'form':
+      return ',';
+    case 'pipeDelimited':
+      return '|';
+    case 'spaceDelimited':
+      return '%20';
+    default:
+      return ',';
+  }
+};
+
+export const separatorObjectExplode = (style: ObjectSeparatorStyle) => {
+  switch (style) {
+    case 'label':
+      return '.';
+    case 'matrix':
+      return ';';
+    case 'simple':
+      return ',';
+    default:
+      return '&';
+  }
+};
+
+export const serializeArrayParam = ({
+  allowReserved,
+  explode,
+  name,
+  style,
+  value,
+}: SerializeOptions<ArraySeparatorStyle> & {
+  value: unknown[];
+}) => {
+  if (!explode) {
+    const joinedValues = (
+      allowReserved ? value : value.map((v) => encodeURIComponent(v as string))
+    ).join(separatorArrayNoExplode(style));
+    switch (style) {
+      case 'label':
+        return `.${joinedValues}`;
+      case 'matrix':
+        return `;${name}=${joinedValues}`;
+      case 'simple':
+        return joinedValues;
+      default:
+        return `${name}=${joinedValues}`;
+    }
+  }
+
+  const separator = separatorArrayExplode(style);
+  const joinedValues = value
+    .map((v) => {
+      if (style === 'label' || style === 'simple') {
+        return allowReserved ? v : encodeURIComponent(v as string);
+      }
+
+      return serializePrimitiveParam({
+        allowReserved,
+        name,
+        value: v as string,
+      });
+    })
+    .join(separator);
+  return style === 'label' || style === 'matrix'
+    ? separator + joinedValues
+    : joinedValues;
+};
+
+export const serializePrimitiveParam = ({
+  allowReserved,
+  name,
+  value,
+}: SerializePrimitiveParam) => {
+  if (value === undefined || value === null) {
+    return '';
+  }
+
+  if (typeof value === 'object') {
+    throw new Error(
+      'Deeply-nested arrays/objects aren’t supported. Provide your own `querySerializer()` to handle these.',
+    );
+  }
+
+  return `${name}=${allowReserved ? value : encodeURIComponent(value)}`;
+};
+
+export const serializeObjectParam = ({
+  allowReserved,
+  explode,
+  name,
+  style,
+  value,
+  valueOnly,
+}: SerializeOptions<ObjectSeparatorStyle> & {
+  value: Record<string, unknown> | Date;
+  valueOnly?: boolean;
+}) => {
+  if (value instanceof Date) {
+    return valueOnly ? value.toISOString() : `${name}=${value.toISOString()}`;
+  }
+
+  if (style !== 'deepObject' && !explode) {
+    let values: string[] = [];
+    Object.entries(value).forEach(([key, v]) => {
+      values = [
+        ...values,
+        key,
+        allowReserved ? (v as string) : encodeURIComponent(v as string),
+      ];
+    });
+    const joinedValues = values.join(',');
+    switch (style) {
+      case 'form':
+        return `${name}=${joinedValues}`;
+      case 'label':
+        return `.${joinedValues}`;
+      case 'matrix':
+        return `;${name}=${joinedValues}`;
+      default:
+        return joinedValues;
+    }
+  }
+
+  const separator = separatorObjectExplode(style);
+  const joinedValues = Object.entries(value)
+    .map(([key, v]) =>
+      serializePrimitiveParam({
+        allowReserved,
+        name: style === 'deepObject' ? `${name}[${key}]` : key,
+        value: v as string,
+      }),
+    )
+    .join(separator);
+  return style === 'label' || style === 'matrix'
+    ? separator + joinedValues
+    : joinedValues;
+};

modules/frontend/src/api/core/queryKeySerializer.gen.ts

@@ -0,0 +1,136 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+/**
+ * JSON-friendly union that mirrors what Pinia Colada can hash.
+ */
+export type JsonValue =
+  | null
+  | string
+  | number
+  | boolean
+  | JsonValue[]
+  | { [key: string]: JsonValue };
+
+/**
+ * Replacer that converts non-JSON values (bigint, Date, etc.) to safe substitutes.
+ */
+export const queryKeyJsonReplacer = (_key: string, value: unknown) => {
+  if (
+    value === undefined ||
+    typeof value === 'function' ||
+    typeof value === 'symbol'
+  ) {
+    return undefined;
+  }
+  if (typeof value === 'bigint') {
+    return value.toString();
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  return value;
+};
+
+/**
+ * Safely stringifies a value and parses it back into a JsonValue.
+ */
+export const stringifyToJsonValue = (input: unknown): JsonValue | undefined => {
+  try {
+    const json = JSON.stringify(input, queryKeyJsonReplacer);
+    if (json === undefined) {
+      return undefined;
+    }
+    return JSON.parse(json) as JsonValue;
+  } catch {
+    return undefined;
+  }
+};
+
+/**
+ * Detects plain objects (including objects with a null prototype).
+ */
+const isPlainObject = (value: unknown): value is Record<string, unknown> => {
+  if (value === null || typeof value !== 'object') {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value as object);
+  return prototype === Object.prototype || prototype === null;
+};
+
+/**
+ * Turns URLSearchParams into a sorted JSON object for deterministic keys.
+ */
+const serializeSearchParams = (params: URLSearchParams): JsonValue => {
+  const entries = Array.from(params.entries()).sort(([a], [b]) =>
+    a.localeCompare(b),
+  );
+  const result: Record<string, JsonValue> = {};
+
+  for (const [key, value] of entries) {
+    const existing = result[key];
+    if (existing === undefined) {
+      result[key] = value;
+      continue;
+    }
+
+    if (Array.isArray(existing)) {
+      (existing as string[]).push(value);
+    } else {
+      result[key] = [existing, value];
+    }
+  }
+
+  return result;
+};
+
+/**
+ * Normalizes any accepted value into a JSON-friendly shape for query keys.
+ */
+export const serializeQueryKeyValue = (
+  value: unknown,
+): JsonValue | undefined => {
+  if (value === null) {
+    return null;
+  }
+
+  if (
+    typeof value === 'string' ||
+    typeof value === 'number' ||
+    typeof value === 'boolean'
+  ) {
+    return value;
+  }
+
+  if (
+    value === undefined ||
+    typeof value === 'function' ||
+    typeof value === 'symbol'
+  ) {
+    return undefined;
+  }
+
+  if (typeof value === 'bigint') {
+    return value.toString();
+  }
+
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+
+  if (Array.isArray(value)) {
+    return stringifyToJsonValue(value);
+  }
+
+  if (
+    typeof URLSearchParams !== 'undefined' &&
+    value instanceof URLSearchParams
+  ) {
+    return serializeSearchParams(value);
+  }
+
+  if (isPlainObject(value)) {
+    return stringifyToJsonValue(value);
+  }
+
+  return undefined;
+};

modules/frontend/src/api/core/serverSentEvents.gen.ts

@@ -0,0 +1,264 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import type { Config } from './types.gen';
+
+export type ServerSentEventsOptions<TData = unknown> = Omit<
+  RequestInit,
+  'method'
+> &
+  Pick<Config, 'method' | 'responseTransformer' | 'responseValidator'> & {
+    /**
+     * Fetch API implementation. You can use this option to provide a custom
+     * fetch instance.
+     *
+     * @default globalThis.fetch
+     */
+    fetch?: typeof fetch;
+    /**
+     * Implementing clients can call request interceptors inside this hook.
+     */
+    onRequest?: (url: string, init: RequestInit) => Promise<Request>;
+    /**
+     * Callback invoked when a network or parsing error occurs during streaming.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @param error The error that occurred.
+     */
+    onSseError?: (error: unknown) => void;
+    /**
+     * Callback invoked when an event is streamed from the server.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @param event Event streamed from the server.
+     * @returns Nothing (void).
+     */
+    onSseEvent?: (event: StreamEvent<TData>) => void;
+    serializedBody?: RequestInit['body'];
+    /**
+     * Default retry delay in milliseconds.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @default 3000
+     */
+    sseDefaultRetryDelay?: number;
+    /**
+     * Maximum number of retry attempts before giving up.
+     */
+    sseMaxRetryAttempts?: number;
+    /**
+     * Maximum retry delay in milliseconds.
+     *
+     * Applies only when exponential backoff is used.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @default 30000
+     */
+    sseMaxRetryDelay?: number;
+    /**
+     * Optional sleep function for retry backoff.
+     *
+     * Defaults to using `setTimeout`.
+     */
+    sseSleepFn?: (ms: number) => Promise<void>;
+    url: string;
+  };
+
+export interface StreamEvent<TData = unknown> {
+  data: TData;
+  event?: string;
+  id?: string;
+  retry?: number;
+}
+
+export type ServerSentEventsResult<
+  TData = unknown,
+  TReturn = void,
+  TNext = unknown,
+> = {
+  stream: AsyncGenerator<
+    TData extends Record<string, unknown> ? TData[keyof TData] : TData,
+    TReturn,
+    TNext
+  >;
+};
+
+export const createSseClient = <TData = unknown>({
+  onRequest,
+  onSseError,
+  onSseEvent,
+  responseTransformer,
+  responseValidator,
+  sseDefaultRetryDelay,
+  sseMaxRetryAttempts,
+  sseMaxRetryDelay,
+  sseSleepFn,
+  url,
+  ...options
+}: ServerSentEventsOptions): ServerSentEventsResult<TData> => {
+  let lastEventId: string | undefined;
+
+  const sleep =
+    sseSleepFn ??
+    ((ms: number) => new Promise((resolve) => setTimeout(resolve, ms)));
+
+  const createStream = async function* () {
+    let retryDelay: number = sseDefaultRetryDelay ?? 3000;
+    let attempt = 0;
+    const signal = options.signal ?? new AbortController().signal;
+
+    while (true) {
+      if (signal.aborted) break;
+
+      attempt++;
+
+      const headers =
+        options.headers instanceof Headers
+          ? options.headers
+          : new Headers(options.headers as Record<string, string> | undefined);
+
+      if (lastEventId !== undefined) {
+        headers.set('Last-Event-ID', lastEventId);
+      }
+
+      try {
+        const requestInit: RequestInit = {
+          redirect: 'follow',
+          ...options,
+          body: options.serializedBody,
+          headers,
+          signal,
+        };
+        let request = new Request(url, requestInit);
+        if (onRequest) {
+          request = await onRequest(url, requestInit);
+        }
+        // fetch must be assigned here, otherwise it would throw the error:
+        // TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation
+        const _fetch = options.fetch ?? globalThis.fetch;
+        const response = await _fetch(request);
+
+        if (!response.ok)
+          throw new Error(
+            `SSE failed: ${response.status} ${response.statusText}`,
+          );
+
+        if (!response.body) throw new Error('No body in SSE response');
+
+        const reader = response.body
+          .pipeThrough(new TextDecoderStream())
+          .getReader();
+
+        let buffer = '';
+
+        const abortHandler = () => {
+          try {
+            reader.cancel();
+          } catch {
+            // noop
+          }
+        };
+
+        signal.addEventListener('abort', abortHandler);
+
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            buffer += value;
+
+            const chunks = buffer.split('\n\n');
+            buffer = chunks.pop() ?? '';
+
+            for (const chunk of chunks) {
+              const lines = chunk.split('\n');
+              const dataLines: Array<string> = [];
+              let eventName: string | undefined;
+
+              for (const line of lines) {
+                if (line.startsWith('data:')) {
+                  dataLines.push(line.replace(/^data:\s*/, ''));
+                } else if (line.startsWith('event:')) {
+                  eventName = line.replace(/^event:\s*/, '');
+                } else if (line.startsWith('id:')) {
+                  lastEventId = line.replace(/^id:\s*/, '');
+                } else if (line.startsWith('retry:')) {
+                  const parsed = Number.parseInt(
+                    line.replace(/^retry:\s*/, ''),
+                    10,
+                  );
+                  if (!Number.isNaN(parsed)) {
+                    retryDelay = parsed;
+                  }
+                }
+              }
+
+              let data: unknown;
+              let parsedJson = false;
+
+              if (dataLines.length) {
+                const rawData = dataLines.join('\n');
+                try {
+                  data = JSON.parse(rawData);
+                  parsedJson = true;
+                } catch {
+                  data = rawData;
+                }
+              }
+
+              if (parsedJson) {
+                if (responseValidator) {
+                  await responseValidator(data);
+                }
+
+                if (responseTransformer) {
+                  data = await responseTransformer(data);
+                }
+              }
+
+              onSseEvent?.({
+                data,
+                event: eventName,
+                id: lastEventId,
+                retry: retryDelay,
+              });
+
+              if (dataLines.length) {
+                yield data as any;
+              }
+            }
+          }
+        } finally {
+          signal.removeEventListener('abort', abortHandler);
+          reader.releaseLock();
+        }
+
+        break; // exit loop on normal completion
+      } catch (error) {
+        // connection failed or aborted; retry after delay
+        onSseError?.(error);
+
+        if (
+          sseMaxRetryAttempts !== undefined &&
+          attempt >= sseMaxRetryAttempts
+        ) {
+          break; // stop after firing error
+        }
+
+        // exponential backoff: double retry each attempt, cap at 30s
+        const backoff = Math.min(
+          retryDelay * 2 ** (attempt - 1),
+          sseMaxRetryDelay ?? 30000,
+        );
+        await sleep(backoff);
+      }
+    }
+  };
+
+  const stream = createStream();
+
+  return { stream };
+};

modules/frontend/src/api/core/types.gen.ts

@@ -0,0 +1,118 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import type { Auth, AuthToken } from './auth.gen';
+import type {
+  BodySerializer,
+  QuerySerializer,
+  QuerySerializerOptions,
+} from './bodySerializer.gen';
+
+export type HttpMethod =
+  | 'connect'
+  | 'delete'
+  | 'get'
+  | 'head'
+  | 'options'
+  | 'patch'
+  | 'post'
+  | 'put'
+  | 'trace';
+
+export type Client<
+  RequestFn = never,
+  Config = unknown,
+  MethodFn = never,
+  BuildUrlFn = never,
+  SseFn = never,
+> = {
+  /**
+   * Returns the final request URL.
+   */
+  buildUrl: BuildUrlFn;
+  getConfig: () => Config;
+  request: RequestFn;
+  setConfig: (config: Config) => Config;
+} & {
+  [K in HttpMethod]: MethodFn;
+} & ([SseFn] extends [never]
+    ? { sse?: never }
+    : { sse: { [K in HttpMethod]: SseFn } });
+
+export interface Config {
+  /**
+   * Auth token or a function returning auth token. The resolved value will be
+   * added to the request payload as defined by its `security` array.
+   */
+  auth?: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken;
+  /**
+   * A function for serializing request body parameter. By default,
+   * {@link JSON.stringify()} will be used.
+   */
+  bodySerializer?: BodySerializer | null;
+  /**
+   * An object containing any HTTP headers that you want to pre-populate your
+   * `Headers` object with.
+   *
+   * {@link https://developer.mozilla.org/docs/Web/API/Headers/Headers#init See more}
+   */
+  headers?:
+    | RequestInit['headers']
+    | Record<
+        string,
+        | string
+        | number
+        | boolean
+        | (string | number | boolean)[]
+        | null
+        | undefined
+        | unknown
+      >;
+  /**
+   * The request method.
+   *
+   * {@link https://developer.mozilla.org/docs/Web/API/fetch#method See more}
+   */
+  method?: Uppercase<HttpMethod>;
+  /**
+   * A function for serializing request query parameters. By default, arrays
+   * will be exploded in form style, objects will be exploded in deepObject
+   * style, and reserved characters are percent-encoded.
+   *
+   * This method will have no effect if the native `paramsSerializer()` Axios
+   * API function is used.
+   *
+   * {@link https://swagger.io/docs/specification/serialization/#query View examples}
+   */
+  querySerializer?: QuerySerializer | QuerySerializerOptions;
+  /**
+   * A function validating request data. This is useful if you want to ensure
+   * the request conforms to the desired shape, so it can be safely sent to
+   * the server.
+   */
+  requestValidator?: (data: unknown) => Promise<unknown>;
+  /**
+   * A function transforming response data before it's returned. This is useful
+   * for post-processing data, e.g. converting ISO strings into Date objects.
+   */
+  responseTransformer?: (data: unknown) => Promise<unknown>;
+  /**
+   * A function validating response data. This is useful if you want to ensure
+   * the response conforms to the desired shape, so it can be safely passed to
+   * the transformers and returned to the user.
+   */
+  responseValidator?: (data: unknown) => Promise<unknown>;
+}
+
+type IsExactlyNeverOrNeverUndefined<T> = [T] extends [never]
+  ? true
+  : [T] extends [never | undefined]
+    ? [undefined] extends [T]
+      ? false
+      : true
+    : false;
+
+export type OmitNever<T extends Record<string, unknown>> = {
+  [K in keyof T as IsExactlyNeverOrNeverUndefined<T[K]> extends true
+    ? never
+    : K]: T[K];
+};

modules/frontend/src/api/core/utils.gen.ts

@@ -0,0 +1,143 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import type { BodySerializer, QuerySerializer } from './bodySerializer.gen';
+import {
+  type ArraySeparatorStyle,
+  serializeArrayParam,
+  serializeObjectParam,
+  serializePrimitiveParam,
+} from './pathSerializer.gen';
+
+export interface PathSerializer {
+  path: Record<string, unknown>;
+  url: string;
+}
+
+export const PATH_PARAM_RE = /\{[^{}]+\}/g;
+
+export const defaultPathSerializer = ({ path, url: _url }: PathSerializer) => {
+  let url = _url;
+  const matches = _url.match(PATH_PARAM_RE);
+  if (matches) {
+    for (const match of matches) {
+      let explode = false;
+      let name = match.substring(1, match.length - 1);
+      let style: ArraySeparatorStyle = 'simple';
+
+      if (name.endsWith('*')) {
+        explode = true;
+        name = name.substring(0, name.length - 1);
+      }
+
+      if (name.startsWith('.')) {
+        name = name.substring(1);
+        style = 'label';
+      } else if (name.startsWith(';')) {
+        name = name.substring(1);
+        style = 'matrix';
+      }
+
+      const value = path[name];
+
+      if (value === undefined || value === null) {
+        continue;
+      }
+
+      if (Array.isArray(value)) {
+        url = url.replace(
+          match,
+          serializeArrayParam({ explode, name, style, value }),
+        );
+        continue;
+      }
+
+      if (typeof value === 'object') {
+        url = url.replace(
+          match,
+          serializeObjectParam({
+            explode,
+            name,
+            style,
+            value: value as Record<string, unknown>,
+            valueOnly: true,
+          }),
+        );
+        continue;
+      }
+
+      if (style === 'matrix') {
+        url = url.replace(
+          match,
+          `;${serializePrimitiveParam({
+            name,
+            value: value as string,
+          })}`,
+        );
+        continue;
+      }
+
+      const replaceValue = encodeURIComponent(
+        style === 'label' ? `.${value as string}` : (value as string),
+      );
+      url = url.replace(match, replaceValue);
+    }
+  }
+  return url;
+};
+
+export const getUrl = ({
+  baseUrl,
+  path,
+  query,
+  querySerializer,
+  url: _url,
+}: {
+  baseUrl?: string;
+  path?: Record<string, unknown>;
+  query?: Record<string, unknown>;
+  querySerializer: QuerySerializer;
+  url: string;
+}) => {
+  const pathUrl = _url.startsWith('/') ? _url : `/${_url}`;
+  let url = (baseUrl ?? '') + pathUrl;
+  if (path) {
+    url = defaultPathSerializer({ path, url });
+  }
+  let search = query ? querySerializer(query) : '';
+  if (search.startsWith('?')) {
+    search = search.substring(1);
+  }
+  if (search) {
+    url += `?${search}`;
+  }
+  return url;
+};
+
+export function getValidRequestBody(options: {
+  body?: unknown;
+  bodySerializer?: BodySerializer | null;
+  serializedBody?: unknown;
+}) {
+  const hasBody = options.body !== undefined;
+  const isSerializedBody = hasBody && options.bodySerializer;
+
+  if (isSerializedBody) {
+    if ('serializedBody' in options) {
+      const hasSerializedBody =
+        options.serializedBody !== undefined && options.serializedBody !== '';
+
+      return hasSerializedBody ? options.serializedBody : null;
+    }
+
+    // not all clients implement a serializedBody property (i.e. client-axios)
+    return options.body !== '' ? options.body : null;
+  }
+
+  // plain/text body
+  if (hasBody) {
+    return options.body;
+  }
+
+  // no body was provided
+  return undefined;
+}

modules/frontend/src/api/index.ts

@@ -1,16 +1,4 @@
-/* generated using openapi-typescript-codegen -- do not edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-export { ApiError } from './core/ApiError';
-export { CancelablePromise, CancelError } from './core/CancelablePromise';
-export { OpenAPI } from './core/OpenAPI';
-export type { OpenAPIConfig } from './core/OpenAPI';
+// This file is auto-generated by @hey-api/openapi-ts
 
-export type { Review } from './models/Review';
-export type { Tag } from './models/Tag';
-export type { Title } from './models/Title';
-export type { User } from './models/User';
-export type { UserTitle } from './models/UserTitle';
-
-export { DefaultService } from './services/DefaultService';
+export type * from './types.gen';
+export * from './sdk.gen';

modules/frontend/src/api/models/Review.ts

@@ -1,5 +0,0 @@
-/* generated using openapi-typescript-codegen -- do not edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-export type Review = Record<string, any>;

modules/frontend/src/api/models/Tag.ts

@@ -1,5 +0,0 @@
-/* generated using openapi-typescript-codegen -- do not edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-export type Tag = Record<string, any>;

modules/frontend/src/api/models/Title.ts

@@ -1,5 +0,0 @@
-/* generated using openapi-typescript-codegen -- do not edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-export type Title = Record<string, any>;

modules/frontend/src/api/models/User.ts

@@ -1,35 +0,0 @@
-/* generated using openapi-typescript-codegen -- do not edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-export type User = {
-    /**
-     * Unique user ID (primary key)
-     */
-    id?: number;
-    /**
-     * ID of the user avatar (references images table)
-     */
-    avatar_id?: number | null;
-    /**
-     * User email
-     */
-    mail?: string;
-    /**
-     * Username (alphanumeric + _ or -)
-     */
-    nickname: string;
-    /**
-     * Display name
-     */
-    disp_name?: string;
-    /**
-     * User description
-     */
-    user_desc?: string;
-    /**
-     * Timestamp when the user was created
-     */
-    creation_date: string;
-};
-

modules/frontend/src/api/models/UserTitle.ts

@@ -1,5 +0,0 @@
-/* generated using openapi-typescript-codegen -- do not edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-export type UserTitle = Record<string, any>;

modules/frontend/src/api/sdk.gen.ts

@@ -0,0 +1,110 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import type { Client, Options as Options2, TDataShape } from './client';
+import { client } from './client.gen';
+import type { AddUserTitleData, AddUserTitleErrors, AddUserTitleResponses, DeleteUserTitleData, DeleteUserTitleErrors, DeleteUserTitleResponses, GetTitleData, GetTitleErrors, GetTitleResponses, GetTitlesData, GetTitlesErrors, GetTitlesResponses, GetUsersIdData, GetUsersIdErrors, GetUsersIdResponses, GetUserTitleData, GetUserTitleErrors, GetUserTitleResponses, GetUserTitlesData, GetUserTitlesErrors, GetUserTitlesResponses, UpdateUserData, UpdateUserErrors, UpdateUserResponses, UpdateUserTitleData, UpdateUserTitleErrors, UpdateUserTitleResponses } from './types.gen';
+
+export type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean> = Options2<TData, ThrowOnError> & {
+    /**
+     * You can provide a client instance returned by `createClient()` instead of
+     * individual options. This might be also useful if you want to implement a
+     * custom client.
+     */
+    client?: Client;
+    /**
+     * You can pass arbitrary values through the `meta` object. This can be
+     * used to access values that aren't defined as part of the SDK function.
+     */
+    meta?: Record<string, unknown>;
+};
+
+/**
+ * Get titles
+ */
+export const getTitles = <ThrowOnError extends boolean = false>(options?: Options<GetTitlesData, ThrowOnError>) => (options?.client ?? client).get<GetTitlesResponses, GetTitlesErrors, ThrowOnError>({
+    querySerializer: { parameters: { status: { array: { explode: false } } } },
+    url: '/titles',
+    ...options
+});
+
+/**
+ * Get title description
+ */
+export const getTitle = <ThrowOnError extends boolean = false>(options: Options<GetTitleData, ThrowOnError>) => (options.client ?? client).get<GetTitleResponses, GetTitleErrors, ThrowOnError>({ url: '/titles/{title_id}', ...options });
+
+/**
+ * Get user info
+ */
+export const getUsersId = <ThrowOnError extends boolean = false>(options: Options<GetUsersIdData, ThrowOnError>) => (options.client ?? client).get<GetUsersIdResponses, GetUsersIdErrors, ThrowOnError>({ url: '/users/{user_id}', ...options });
+
+/**
+ * Partially update a user account
+ *
+ * Update selected user profile fields (excluding password).
+ * Password updates must be done via the dedicated auth-service (`/auth/`).
+ * Fields not provided in the request body remain unchanged.
+ *
+ */
+export const updateUser = <ThrowOnError extends boolean = false>(options: Options<UpdateUserData, ThrowOnError>) => (options.client ?? client).patch<UpdateUserResponses, UpdateUserErrors, ThrowOnError>({
+    security: [{ name: 'X-XSRF-TOKEN', type: 'apiKey' }],
+    url: '/users/{user_id}',
+    ...options,
+    headers: {
+        'Content-Type': 'application/json',
+        ...options.headers
+    }
+});
+
+/**
+ * Get user titles
+ */
+export const getUserTitles = <ThrowOnError extends boolean = false>(options: Options<GetUserTitlesData, ThrowOnError>) => (options.client ?? client).get<GetUserTitlesResponses, GetUserTitlesErrors, ThrowOnError>({
+    querySerializer: { parameters: { status: { array: { explode: false } }, watch_status: { array: { explode: false } } } },
+    url: '/users/{user_id}/titles',
+    ...options
+});
+
+/**
+ * Add a title to a user
+ *
+ * User adding title to list af watched, status required
+ */
+export const addUserTitle = <ThrowOnError extends boolean = false>(options: Options<AddUserTitleData, ThrowOnError>) => (options.client ?? client).post<AddUserTitleResponses, AddUserTitleErrors, ThrowOnError>({
+    url: '/users/{user_id}/titles',
+    ...options,
+    headers: {
+        'Content-Type': 'application/json',
+        ...options.headers
+    }
+});
+
+/**
+ * Delete a usertitle
+ *
+ * User deleting title from list of watched
+ */
+export const deleteUserTitle = <ThrowOnError extends boolean = false>(options: Options<DeleteUserTitleData, ThrowOnError>) => (options.client ?? client).delete<DeleteUserTitleResponses, DeleteUserTitleErrors, ThrowOnError>({
+    security: [{ name: 'X-XSRF-TOKEN', type: 'apiKey' }],
+    url: '/users/{user_id}/titles/{title_id}',
+    ...options
+});
+
+/**
+ * Get user title
+ */
+export const getUserTitle = <ThrowOnError extends boolean = false>(options: Options<GetUserTitleData, ThrowOnError>) => (options.client ?? client).get<GetUserTitleResponses, GetUserTitleErrors, ThrowOnError>({ url: '/users/{user_id}/titles/{title_id}', ...options });
+
+/**
+ * Update a usertitle
+ *
+ * User updating title list of watched
+ */
+export const updateUserTitle = <ThrowOnError extends boolean = false>(options: Options<UpdateUserTitleData, ThrowOnError>) => (options.client ?? client).patch<UpdateUserTitleResponses, UpdateUserTitleErrors, ThrowOnError>({
+    security: [{ name: 'X-XSRF-TOKEN', type: 'apiKey' }],
+    url: '/users/{user_id}/titles/{title_id}',
+    ...options,
+    headers: {
+        'Content-Type': 'application/json',
+        ...options.headers
+    }
+});

modules/frontend/src/api/services/DefaultService.ts

@@ -1,35 +0,0 @@
-/* generated using openapi-typescript-codegen -- do not edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-import type { User } from '../models/User';
-import type { CancelablePromise } from '../core/CancelablePromise';
-import { OpenAPI } from '../core/OpenAPI';
-import { request as __request } from '../core/request';
-export class DefaultService {
-    /**
-     * Get user info
-     * @param userId
-     * @param fields
-     * @returns User User info
-     * @throws ApiError
-     */
-    public static getUsers(
-        userId: string,
-        fields: string = 'all',
-    ): CancelablePromise<User> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/users/{user_id}',
-            path: {
-                'user_id': userId,
-            },
-            query: {
-                'fields': fields,
-            },
-            errors: {
-                404: `User not found`,
-            },
-        });
-    }
-}

modules/frontend/src/api/types.gen.ts

@@ -0,0 +1,570 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+export type ClientOptions = {
+    baseUrl: `${string}://${string}/api/v1` | (string & {});
+};
+
+/**
+ * Title sort order
+ */
+export type TitleSort = 'id' | 'year' | 'rating' | 'views';
+
+/**
+ * Title status
+ */
+export type TitleStatus = 'finished' | 'ongoing' | 'planned';
+
+/**
+ * Title release season
+ */
+export type ReleaseSeason = 'winter' | 'spring' | 'summer' | 'fall';
+
+/**
+ * Image storage type
+ */
+export type StorageType = 's3' | 'local';
+
+export type Image = {
+    id?: number;
+    storage_type?: StorageType;
+    image_path?: string;
+};
+
+export type Studio = {
+    id: number;
+    name: string;
+    poster?: Image;
+    description?: string;
+};
+
+/**
+ * A localized tag: keys are language codes (ISO 639-1), values are tag names
+ */
+export type Tag = {
+    [key: string]: string;
+};
+
+/**
+ * Array of localized tags
+ */
+export type Tags = Array<Tag>;
+
+export type Title = {
+    /**
+     * Unique title ID (primary key)
+     */
+    id: number;
+    /**
+     * Localized titles. Key = language (ISO 639-1), value = list of names
+     */
+    title_names: {
+        [key: string]: Array<string>;
+    };
+    studio?: Studio;
+    tags: Tags;
+    poster?: Image;
+    title_status?: TitleStatus;
+    rating?: number;
+    rating_count?: number;
+    release_year?: number;
+    release_season?: ReleaseSeason;
+    episodes_aired?: number;
+    episodes_all?: number;
+    episodes_len?: {
+        [key: string]: number;
+    };
+};
+
+export type CursorObj = {
+    id: number;
+    param?: string;
+};
+
+export type User = {
+    /**
+     * Unique user ID (primary key)
+     */
+    id?: number;
+    image?: Image;
+    /**
+     * User email
+     */
+    mail?: string;
+    /**
+     * Username (alphanumeric + _ or -)
+     */
+    nickname: string;
+    /**
+     * Display name
+     */
+    disp_name?: string;
+    /**
+     * User description
+     */
+    user_desc?: string;
+    /**
+     * Timestamp when the user was created
+     */
+    creation_date?: string;
+};
+
+/**
+ * User's title status
+ */
+export type UserTitleStatus = 'finished' | 'planned' | 'dropped' | 'in-progress';
+
+export type UserTitle = {
+    user_id: number;
+    title?: Title;
+    status: UserTitleStatus;
+    rate?: number;
+    review_id?: number;
+    ctime?: string;
+};
+
+export type UserTitleMini = {
+    user_id: number;
+    title_id: number;
+    status: UserTitleStatus;
+    rate?: number;
+    review_id?: number;
+    ctime?: string;
+};
+
+export type Review = {
+    [key: string]: unknown;
+};
+
+export type Cursor = string;
+
+export type TitleSort2 = TitleSort;
+
+export type GetTitlesData = {
+    body?: never;
+    path?: never;
+    query?: {
+        cursor?: string;
+        sort?: TitleSort;
+        sort_forward?: boolean;
+        ext_search?: boolean;
+        word?: string;
+        /**
+         * List of title statuses to filter
+         */
+        status?: Array<TitleStatus>;
+        rating?: number;
+        release_year?: number;
+        release_season?: ReleaseSeason;
+        limit?: number;
+        offset?: number;
+        fields?: string;
+    };
+    url: '/titles';
+};
+
+export type GetTitlesErrors = {
+    /**
+     * Request params are not correct
+     */
+    400: unknown;
+    /**
+     * Unknown server error
+     */
+    500: unknown;
+};
+
+export type GetTitlesResponses = {
+    /**
+     * List of titles with cursor
+     */
+    200: {
+        /**
+         * List of titles
+         */
+        data: Array<Title>;
+        cursor: CursorObj;
+    };
+    /**
+     * No titles found
+     */
+    204: void;
+};
+
+export type GetTitlesResponse = GetTitlesResponses[keyof GetTitlesResponses];
+
+export type GetTitleData = {
+    body?: never;
+    path: {
+        title_id: number;
+    };
+    query?: {
+        fields?: string;
+    };
+    url: '/titles/{title_id}';
+};
+
+export type GetTitleErrors = {
+    /**
+     * Request params are not correct
+     */
+    400: unknown;
+    /**
+     * Title not found
+     */
+    404: unknown;
+    /**
+     * Unknown server error
+     */
+    500: unknown;
+};
+
+export type GetTitleResponses = {
+    /**
+     * Title description
+     */
+    200: Title;
+    /**
+     * No title found
+     */
+    204: void;
+};
+
+export type GetTitleResponse = GetTitleResponses[keyof GetTitleResponses];
+
+export type GetUsersIdData = {
+    body?: never;
+    path: {
+        user_id: string;
+    };
+    query?: {
+        fields?: string;
+    };
+    url: '/users/{user_id}';
+};
+
+export type GetUsersIdErrors = {
+    /**
+     * Request params are not correct
+     */
+    400: unknown;
+    /**
+     * User not found
+     */
+    404: unknown;
+    /**
+     * Unknown server error
+     */
+    500: unknown;
+};
+
+export type GetUsersIdResponses = {
+    /**
+     * User info
+     */
+    200: User;
+};
+
+export type GetUsersIdResponse = GetUsersIdResponses[keyof GetUsersIdResponses];
+
+export type UpdateUserData = {
+    /**
+     * Only provided fields are updated. Omitted fields remain unchanged.
+     */
+    body: {
+        /**
+         * ID of the user avatar (references `images.id`); set to `null` to remove avatar
+         */
+        avatar_id?: number | null;
+        /**
+         * User email (must be unique and valid)
+         */
+        mail?: string;
+        /**
+         * Username (alphanumeric + `_` or `-`, 3–16 chars)
+         */
+        nickname?: string;
+        /**
+         * Display name
+         */
+        disp_name?: string;
+        /**
+         * User description / bio
+         */
+        user_desc?: string;
+    };
+    path: {
+        /**
+         * User ID (primary key)
+         */
+        user_id: number;
+    };
+    query?: never;
+    url: '/users/{user_id}';
+};
+
+export type UpdateUserErrors = {
+    /**
+     * Invalid input (e.g., validation failed, nickname/email conflict, malformed JSON)
+     */
+    400: unknown;
+    /**
+     * Unauthorized — missing or invalid authentication token
+     */
+    401: unknown;
+    /**
+     * Forbidden — user is not allowed to modify this resource (e.g., not own profile & no admin rights)
+     */
+    403: unknown;
+    /**
+     * User not found
+     */
+    404: unknown;
+    /**
+     * Conflict — e.g., requested `nickname` or `mail` already taken by another user
+     */
+    409: unknown;
+    /**
+     * Unprocessable Entity — semantic errors not caught by schema (e.g., invalid `avatar_id`)
+     */
+    422: unknown;
+    /**
+     * Unknown server error
+     */
+    500: unknown;
+};
+
+export type UpdateUserResponses = {
+    /**
+     * User updated successfully. Returns updated user representation (excluding sensitive fields).
+     */
+    200: User;
+};
+
+export type UpdateUserResponse = UpdateUserResponses[keyof UpdateUserResponses];
+
+export type GetUserTitlesData = {
+    body?: never;
+    path: {
+        user_id: string;
+    };
+    query?: {
+        cursor?: string;
+        sort?: TitleSort;
+        sort_forward?: boolean;
+        word?: string;
+        /**
+         * List of title statuses to filter
+         */
+        status?: Array<TitleStatus>;
+        watch_status?: Array<UserTitleStatus>;
+        rating?: number;
+        my_rate?: number;
+        release_year?: number;
+        release_season?: ReleaseSeason;
+        limit?: number;
+        fields?: string;
+    };
+    url: '/users/{user_id}/titles';
+};
+
+export type GetUserTitlesErrors = {
+    /**
+     * Request params are not correct
+     */
+    400: unknown;
+    /**
+     * User not found
+     */
+    404: unknown;
+    /**
+     * Unknown server error
+     */
+    500: unknown;
+};
+
+export type GetUserTitlesResponses = {
+    /**
+     * List of user titles
+     */
+    200: {
+        data: Array<UserTitle>;
+        cursor: CursorObj;
+    };
+    /**
+     * No titles found
+     */
+    204: void;
+};
+
+export type GetUserTitlesResponse = GetUserTitlesResponses[keyof GetUserTitlesResponses];
+
+export type AddUserTitleData = {
+    body: {
+        title_id: number;
+        status: UserTitleStatus;
+        rate?: number;
+    };
+    path: {
+        /**
+         * ID of the user to assign the title to
+         */
+        user_id: number;
+    };
+    query?: never;
+    url: '/users/{user_id}/titles';
+};
+
+export type AddUserTitleErrors = {
+    /**
+     * Invalid request body (missing fields, invalid types, etc.)
+     */
+    400: unknown;
+    /**
+     * Unauthorized — missing or invalid auth token
+     */
+    401: unknown;
+    /**
+     * Forbidden — user not allowed to assign titles to this user
+     */
+    403: unknown;
+    /**
+     * User or Title not found
+     */
+    404: unknown;
+    /**
+     * Conflict — title already assigned to user (if applicable)
+     */
+    409: unknown;
+    /**
+     * Internal server error
+     */
+    500: unknown;
+};
+
+export type AddUserTitleResponses = {
+    /**
+     * Title successfully added to user
+     */
+    200: UserTitleMini;
+};
+
+export type AddUserTitleResponse = AddUserTitleResponses[keyof AddUserTitleResponses];
+
+export type DeleteUserTitleData = {
+    body?: never;
+    path: {
+        user_id: number;
+        title_id: number;
+    };
+    query?: never;
+    url: '/users/{user_id}/titles/{title_id}';
+};
+
+export type DeleteUserTitleErrors = {
+    /**
+     * Unauthorized — missing or invalid auth token
+     */
+    401: unknown;
+    /**
+     * Forbidden — user not allowed to delete title
+     */
+    403: unknown;
+    /**
+     * User or Title not found
+     */
+    404: unknown;
+    /**
+     * Internal server error
+     */
+    500: unknown;
+};
+
+export type DeleteUserTitleResponses = {
+    /**
+     * Title successfully deleted
+     */
+    200: unknown;
+};
+
+export type GetUserTitleData = {
+    body?: never;
+    path: {
+        user_id: number;
+        title_id: number;
+    };
+    query?: never;
+    url: '/users/{user_id}/titles/{title_id}';
+};
+
+export type GetUserTitleErrors = {
+    /**
+     * Request params are not correct
+     */
+    400: unknown;
+    /**
+     * User or title not found
+     */
+    404: unknown;
+    /**
+     * Unknown server error
+     */
+    500: unknown;
+};
+
+export type GetUserTitleResponses = {
+    /**
+     * User titles
+     */
+    200: UserTitleMini;
+    /**
+     * No user title found
+     */
+    204: void;
+};
+
+export type GetUserTitleResponse = GetUserTitleResponses[keyof GetUserTitleResponses];
+
+export type UpdateUserTitleData = {
+    body: {
+        status?: UserTitleStatus;
+        rate?: number;
+    };
+    path: {
+        user_id: number;
+        title_id: number;
+    };
+    query?: never;
+    url: '/users/{user_id}/titles/{title_id}';
+};
+
+export type UpdateUserTitleErrors = {
+    /**
+     * Invalid request body (missing fields, invalid types, etc.)
+     */
+    400: unknown;
+    /**
+     * Unauthorized — missing or invalid auth token
+     */
+    401: unknown;
+    /**
+     * Forbidden — user not allowed to update title
+     */
+    403: unknown;
+    /**
+     * User or Title not found
+     */
+    404: unknown;
+    /**
+     * Internal server error
+     */
+    500: unknown;
+};
+
+export type UpdateUserTitleResponses = {
+    /**
+     * Title successfully updated
+     */
+    200: UserTitleMini;
+};
+
+export type UpdateUserTitleResponse = UpdateUserTitleResponses[keyof UpdateUserTitleResponses];

modules/frontend/src/auth/core/OpenAPI.ts

@@ -20,7 +20,7 @@ export type OpenAPIConfig = {
 };
 
 export const OpenAPI: OpenAPIConfig = {
-    BASE: '/api/v1',
+    BASE: 'http://10.1.0.65:8081/auth',
     VERSION: '1.0.0',
     WITH_CREDENTIALS: false,
     CREDENTIALS: 'include',

modules/frontend/src/auth/index.ts

@@ -0,0 +1,10 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export { ApiError } from './core/ApiError';
+export { CancelablePromise, CancelError } from './core/CancelablePromise';
+export { OpenAPI } from './core/OpenAPI';
+export type { OpenAPIConfig } from './core/OpenAPI';
+
+export { AuthService } from './services/AuthService';

modules/frontend/src/auth/services/AuthService.ts

@@ -0,0 +1,55 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class AuthService {
+    /**
+     * Sign up a new user
+     * @param requestBody
+     * @returns any Sign-up result
+     * @throws ApiError
+     */
+    public static postSignUp(
+        requestBody: {
+            nickname: string;
+            pass: string;
+        },
+    ): CancelablePromise<{
+        user_id: number;
+    }> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/sign-up',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Sign in a user and return JWT
+     * @param requestBody
+     * @returns any Sign-in result with JWT
+     * @throws ApiError
+     */
+    public static postSignIn(
+        requestBody: {
+            nickname: string;
+            pass: string;
+        },
+    ): CancelablePromise<{
+        user_id: number;
+        user_name: string;
+    }> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/sign-in',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Access denied due to invalid credentials`,
+            },
+        });
+    }
+}

modules/frontend/src/components/Header/Header.tsx

@@ -0,0 +1,90 @@
+import React, { useState } from "react";
+import { Link } from "react-router-dom";
+import { Bars3Icon, XMarkIcon } from "@heroicons/react/24/solid";
+
+type HeaderProps = {
+  username?: string;
+};
+
+export const Header: React.FC<HeaderProps> = ({ username }) => {
+  const [menuOpen, setMenuOpen] = useState(false);
+
+  const toggleMenu = () => setMenuOpen(!menuOpen);
+
+  return (
+    <header className="w-full bg-white shadow-md sticky top-0 left-0 z-50">
+      <div className="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8">
+        <div className="flex justify-between h-16 items-center">
+
+          {/* Левый блок — логотип / название */}
+          <div className="flex-shrink-0">
+            <Link to="/" className="text-xl font-bold text-gray-800 hover:text-blue-600">
+              NyanimeDB
+            </Link>
+          </div>
+
+          {/* Центр — ссылки на разделы (desktop) */}
+          <nav className="hidden md:flex space-x-4">
+            <Link to="/titles" className="text-gray-700 hover:text-blue-600">
+              Titles
+            </Link>
+            <Link to="/users" className="text-gray-700 hover:text-blue-600">
+              Users
+            </Link>
+            <Link to="/about" className="text-gray-700 hover:text-blue-600">
+              About
+            </Link>
+          </nav>
+
+          {/* Правый блок — профиль */}
+          <div className="hidden md:flex items-center space-x-4">
+            {username ? (
+              <Link to="/profile" className="text-gray-700 hover:text-blue-600 font-medium">
+                {username}
+              </Link>
+            ) : (
+              <Link to="/login" className="text-gray-700 hover:text-blue-600 font-medium">
+                Login
+              </Link>
+            )}
+          </div>
+
+          {/* Бургер для мобильного */}
+          <div className="md:hidden flex items-center">
+            <button
+              onClick={toggleMenu}
+              className="p-2 rounded-md hover:bg-gray-200 transition"
+            >
+              {menuOpen ? (
+                <XMarkIcon className="w-6 h-6 text-gray-800" />
+              ) : (
+                <Bars3Icon className="w-6 h-6 text-gray-800" />
+              )}
+            </button>
+          </div>
+
+        </div>
+      </div>
+
+      {/* Мобильное меню */}
+      {menuOpen && (
+        <div className="md:hidden bg-white border-t border-gray-200 shadow-md">
+          <nav className="flex flex-col p-4 space-y-2">
+            <Link to="/titles" className="text-gray-700 hover:text-blue-600" onClick={() => setMenuOpen(false)}>Titles</Link>
+            <Link to="/users" className="text-gray-700 hover:text-blue-600" onClick={() => setMenuOpen(false)}>Users</Link>
+            <Link to="/about" className="text-gray-700 hover:text-blue-600" onClick={() => setMenuOpen(false)}>About</Link>
+            {username ? (
+              <Link to="/profile" className="text-gray-700 hover:text-blue-600 font-medium" onClick={() => setMenuOpen(false)}>
+                {username}
+              </Link>
+            ) : (
+              <Link to="/login" className="text-gray-700 hover:text-blue-600 font-medium" onClick={() => setMenuOpen(false)}>
+                Login
+              </Link>
+            )}
+          </nav>
+        </div>
+      )}
+    </header>
+  );
+};

modules/frontend/src/components/LayoutSwitch/LayoutSwitch.tsx

@@ -0,0 +1,28 @@
+import React from "react";
+import { Squares2X2Icon, Bars3Icon } from "@heroicons/react/24/solid";
+
+export type LayoutSwitchProps = {
+  layout: "square" | "horizontal"
+  setLayout: (value: React.SetStateAction<"square" | "horizontal">) => void
+};
+
+export function LayoutSwitch({
+    layout,
+    setLayout
+}: LayoutSwitchProps) {
+
+  return (
+      <div className="flex justify-end">
+        <button
+          className="p-2 bg-blue-600 text-white rounded-lg hover:bg-blue-700 transition"
+          onClick={() =>
+            setLayout(prev => (prev === "square" ? "horizontal" : "square"))
+          }>
+          {layout === "square"
+            ? <Squares2X2Icon className="w-6 h-6" />
+            : <Bars3Icon className="w-6 h-6" />
+          }
+        </button>
+      </div>
+  );
+}

modules/frontend/src/components/ListView/ListView.tsx

@@ -0,0 +1,48 @@
+import React from "react";
+
+export type ListViewProps<T> = {
+  items: T[];
+  layout:  "square" | "horizontal";
+  renderItem: (item: T, layout: "square" | "horizontal") => React.ReactNode;
+  onLoadMore: () => void;
+  hasMore: boolean;
+  loadingMore: boolean;
+};
+
+export function ListView<T>({
+  items,
+  layout,
+  renderItem,
+  onLoadMore,
+  hasMore,
+  loadingMore
+}: ListViewProps<T>) {
+
+  return (
+    <div className="w-full flex flex-col items-center">
+      {/* Items */}
+      <div
+        className={`w-full sm:w-4/5 grid gap-6 ${
+          layout === "square"
+            ? "grid-cols-1 sm:grid-cols-2 lg:grid-cols-4"
+            : "grid-cols-1"
+        }`}
+      >
+        {items.map(item => renderItem(item, layout))}
+      </div>
+
+      {/* Load More */}
+      {hasMore && (
+        <div className="mt-8">
+          <button
+            className="px-6 py-3 bg-blue-600 text-white rounded-lg hover:bg-blue-700 transition disabled:opacity-50"
+            disabled={loadingMore}
+            onClick={onLoadMore}
+          >
+            {loadingMore ? "Loading..." : "Load More"}
+          </button>
+        </div>
+      )}
+    </div>
+  );
+}

modules/frontend/src/components/SearchBar/SearchBar.tsx

@@ -0,0 +1,34 @@
+type SearchBarProps = {
+  placeholder?: string;
+  search: string;
+  setSearch: (value: string) => void;
+};
+
+export function SearchBar({
+  placeholder = "Search...",
+  search,
+  setSearch,
+}: SearchBarProps) {
+  return (
+    <div className="w-full">
+      <input
+        type="text"
+        value={search}
+        placeholder={placeholder}
+        onChange={(e) => setSearch(e.target.value)}
+        className="
+          w-full 
+          px-4 
+          py-2 
+          border 
+          border-gray-300 
+          rounded-lg 
+          focus:outline-none 
+          focus:ring-2 
+          focus:ring-blue-500 
+          text-black
+        "
+      />
+    </div>
+  );
+}

modules/frontend/src/components/TitleStatusControls/TitleStatusControls.tsx

@@ -0,0 +1,118 @@
+import { useEffect, useState } from "react";
+// import { DefaultService } from "../../api";
+import { addUserTitle, deleteUserTitle, getUserTitle, updateUserTitle } from "../../api";
+import type { UserTitleStatus } from "../../api";
+import { useCookies } from 'react-cookie';
+
+import {
+  ClockIcon,
+  CheckCircleIcon,
+  PlayCircleIcon,
+  XCircleIcon,
+} from "@heroicons/react/24/solid";
+// import { stat } from "fs";
+
+// Статусы с иконками и подписью
+const STATUS_BUTTONS: { status: UserTitleStatus; icon: React.ReactNode; label: string }[] = [
+  { status: "planned", icon: <ClockIcon className="w-5 h-5" />, label: "Planned" },
+  { status: "finished", icon: <CheckCircleIcon className="w-5 h-5" />, label: "Finished" },
+  { status: "in-progress", icon: <PlayCircleIcon className="w-5 h-5" />, label: "In Progress" },
+  { status: "dropped", icon: <XCircleIcon className="w-5 h-5" />, label: "Dropped" },
+];
+
+export function TitleStatusControls({ titleId }: { titleId: number }) {
+    const [cookies] = useCookies(['xsrf_token']);
+    const xsrfToken = cookies['xsrf_token'] || null;
+
+    const [currentStatus, setCurrentStatus] = useState<UserTitleStatus | null>(null);
+    const [loading, setLoading] = useState(false);
+
+    const userIdStr = localStorage.getItem("userId");
+    const userId = userIdStr ? Number(userIdStr) : null;
+
+    // --- Load initial status ---
+    useEffect(() => {
+        if (!userId) return;
+        getUserTitle({ path: { user_id: userId, title_id: titleId } })
+            .then(res => setCurrentStatus(res.data?.status ?? null))
+            .catch(() => setCurrentStatus(null)); // 404 = not assigned
+
+        // DefaultService.getUserTitle(userId, titleId)
+        //     .then((res) => setCurrentStatus(res.status))
+        //     .catch(() => setCurrentStatus(null)); // 404 = user title does not exist
+    }, [titleId, userId]);
+
+    // --- Handle click ---
+    const handleStatusClick = async (status: UserTitleStatus) => {
+        if (!userId || loading) return;
+
+        setLoading(true);
+
+        try {
+            // 1) Если кликнули на текущий статус — DELETE
+            if (currentStatus === status) {
+                // await DefaultService.deleteUserTitle(userId, titleId);
+                await deleteUserTitle({path: {
+                    user_id: userId,
+                    title_id: titleId,
+                },
+                headers: { "X-XSRF-TOKEN": xsrfToken },
+                })
+                setCurrentStatus(null);
+                return;
+            }
+
+            // 2) Если другой статус — POST или PATCH
+            if (!currentStatus) {
+                // ещё нет записи — POST
+                // const added = await DefaultService.addUserTitle(userId, {
+                //     title_id: titleId,
+                //     status,
+                // });
+                const added = await addUserTitle({
+                body: {
+                    title_id: titleId,
+                    status: status,
+                    },
+                path: {user_id: userId},
+                headers: { "X-XSRF-TOKEN": xsrfToken },
+                });
+
+                setCurrentStatus(added.data?.status ?? null);
+            } else {
+                // уже есть запись — PATCH
+                //const updated = await DefaultService.updateUserTitle(userId, titleId, { status });
+                const updated = await updateUserTitle({
+                    path: { user_id: userId, title_id: titleId },
+                    body: { status },
+                    headers: { "X-XSRF-TOKEN": xsrfToken },
+            });
+                setCurrentStatus(updated.data?.status ?? null);
+            }
+        } finally {
+            setLoading(false);
+        }
+    };
+
+    return (
+        <div className="flex gap-2 flex-wrap justify-center mt-2">
+            {STATUS_BUTTONS.map(btn => (
+                <button
+                    key={btn.status}
+                    onClick={() => handleStatusClick(btn.status)}
+                    disabled={loading}
+                    className={`
+                        px-3 py-1 rounded-md border flex items-center gap-1 transition
+                        ${currentStatus === btn.status
+                            ? "bg-blue-600 text-white border-blue-700"
+                            : "bg-gray-200 text-black border-gray-300 hover:bg-gray-300"}
+                    `}
+                    title={btn.label}
+                >
+                    {btn.icon}
+                    <span>{btn.label}</span>
+                </button>
+            ))}
+        </div>
+    );
+}

modules/frontend/src/components/TitlesFilterPanel/TitlesFilterPanel.tsx

@@ -0,0 +1,122 @@
+import { useState } from "react";
+import type { TitleStatus, ReleaseSeason } from "../../api";
+import { ChevronDownIcon, ChevronUpIcon } from "@heroicons/react/24/solid";
+
+export type TitlesFilter = {
+  extSearch: boolean;
+  status: TitleStatus | "";
+  rating: number | "";
+  releaseYear: number | "";
+  releaseSeason: ReleaseSeason | "";
+};
+
+type TitlesFilterPanelProps = {
+  filters: TitlesFilter;
+  setFilters: (filters: TitlesFilter) => void;
+};
+
+const STATUS_OPTIONS: (TitleStatus | "")[] = ["", "planned", "finished", "ongoing"];
+const SEASON_OPTIONS: (ReleaseSeason | "")[] = ["", "winter", "spring", "summer", "fall"];
+const RATING_OPTIONS = ["", 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+
+export function TitlesFilterPanel({ filters, setFilters }: TitlesFilterPanelProps) {
+  const [open, setOpen] = useState(false);
+
+  const handleChange = (field: keyof TitlesFilter, value: any) => {
+    setFilters({ ...filters, [field]: value });
+  };
+
+  return (
+    <div className="w-full flex justify-center my-4">
+      <div className="bg-white shadow rounded-lg w-full max-w-3xl p-4">
+        {/* Заголовок панели */}
+        <div
+          className="flex justify-between items-center cursor-pointer"
+          onClick={() => setOpen((prev) => !prev)}
+        >
+          <h3 className="text-lg font-medium">Filters</h3>
+          {open ? <ChevronUpIcon className="w-5 h-5" /> : <ChevronDownIcon className="w-5 h-5" />}
+        </div>
+
+        {/* Контент панели */}
+        {open && (
+          <div className="mt-4 grid grid-cols-2 sm:grid-cols-3 gap-4">
+            {/* Extended Search */}
+            <div className="flex items-center gap-2">
+              <input
+                type="checkbox"
+                id="extSearch"
+                checked={filters.extSearch}
+                onChange={(e) => handleChange("extSearch", e.target.checked)}
+                className="w-4 h-4"
+              />
+              <label htmlFor="extSearch" className="text-sm">
+                Extended Search
+              </label>
+            </div>
+
+            {/* Status */}
+            <div className="flex flex-col">
+              <label htmlFor="status" className="text-sm mb-1">Status</label>
+              <select
+                id="status"
+                value={filters.status}
+                onChange={(e) => handleChange("status", e.target.value || "")}
+                className="border rounded px-2 py-1"
+              >
+                {STATUS_OPTIONS.map((s) => (
+                  <option key={s || "all"} value={s}>{s || "All"}</option>
+                ))}
+              </select>
+            </div>
+
+            {/* Rating */}
+            <div className="flex flex-col">
+              <label htmlFor="rating" className="text-sm mb-1">Rating</label>
+              <select
+                id="rating"
+                value={filters.rating}
+                onChange={(e) => handleChange("rating", e.target.value ? Number(e.target.value) : "")}
+                className="border rounded px-2 py-1"
+              >
+                {RATING_OPTIONS.map((r) => (
+                  <option key={r} value={r}>{r || "All"}</option>
+                ))}
+              </select>
+            </div>
+
+            {/* Release Year */}
+            <div className="flex flex-col">
+              <label htmlFor="releaseYear" className="text-sm mb-1">Release Year</label>
+              <input
+                type="number"
+                id="releaseYear"
+                value={filters.releaseYear || ""}
+                onChange={(e) =>
+                  handleChange("releaseYear", e.target.value ? Number(e.target.value) : "")
+                }
+                className="border rounded px-2 py-1"
+                placeholder="Any"
+              />
+            </div>
+
+            {/* Release Season */}
+            <div className="flex flex-col">
+              <label htmlFor="releaseSeason" className="text-sm mb-1">Release Season</label>
+              <select
+                id="releaseSeason"
+                value={filters.releaseSeason}
+                onChange={(e) => handleChange("releaseSeason", e.target.value || "")}
+                className="border rounded px-2 py-1"
+              >
+                {SEASON_OPTIONS.map((s) => (
+                  <option key={s || "all"} value={s}>{s || "All"}</option>
+                ))}
+              </select>
+            </div>
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}

modules/frontend/src/components/TitlesSortBox/TitlesSortBox.tsx

@@ -0,0 +1,67 @@
+import { useState } from "react";
+import type { TitleSort } from "../../api";
+import { ChevronDownIcon, ArrowUpIcon, ArrowDownIcon } from "@heroicons/react/24/solid";
+
+type TitlesSortBoxProps = {
+  sort: TitleSort;
+  setSort: (value: TitleSort) => void;
+  sortForward: boolean;
+  setSortForward: (value: boolean) => void;
+};
+
+const SORT_OPTIONS: TitleSort[] = ["id", "rating", "year", "views"];
+
+export function TitlesSortBox({
+  sort,
+  setSort,
+  sortForward,
+  setSortForward,
+}: TitlesSortBoxProps) {
+  const [open, setOpen] = useState(false);
+
+  const toggleSortDirection = () => setSortForward(!sortForward);
+  const handleSortSelect = (newSort: TitleSort) => {
+    setSort(newSort);
+    setOpen(false);
+  };
+
+  return (
+    <div className="inline-flex relative z-50">
+      {/* Левая часть — смена направления */}
+      <button
+        onClick={toggleSortDirection}
+        className="px-4 py-2 flex items-center justify-center bg-gray-100 hover:bg-gray-200 border border-gray-300 rounded-l-lg transition"
+      >
+        {sortForward ? <ArrowUpIcon className="w-4 h-4 mr-1" /> : <ArrowDownIcon className="w-4 h-4 mr-1" />}
+        <span className="text-sm font-medium">Order</span>
+      </button>
+
+      {/* Правая часть — выбор параметра */}
+      <button
+        onClick={() => setOpen(!open)}
+        className="px-4 py-2 flex items-center justify-center bg-gray-100 hover:bg-gray-200 border border-gray-300 border-l-0 rounded-r-lg transition"
+      >
+        <span className="text-sm font-medium">{sort}</span>
+        <ChevronDownIcon className="w-4 h-4 ml-1" />
+      </button>
+
+      {/* Dropdown */}
+      {open && (
+        <ul className="absolute top-full left-0 mt-1 w-40 bg-white border border-gray-300 rounded-md shadow-lg z-[1000]">
+          {SORT_OPTIONS.map(option => (
+            <li key={option}>
+              <button
+                className={`w-full text-left px-4 py-2 hover:bg-gray-100 transition ${
+                  option === sort ? "font-bold bg-gray-100" : ""
+                }`}
+                onClick={() => handleSortSelect(option)}
+              >
+                {option}
+              </button>
+            </li>
+          ))}
+        </ul>
+      )}
+    </div>
+  );
+}

modules/frontend/src/components/UserPage/UserPage.module.css

@@ -1,97 +0,0 @@
-.container {
-  display: flex;
-  justify-content: center;
-  align-items: flex-start;
-  padding: 3rem 1rem;
-  background-color: #f5f6fa;
-  min-height: 100vh;
-  font-family: "Inter", sans-serif;
-}
-
-.card {
-  background-color: #ffffff;
-  border-radius: 1rem;
-  box-shadow: 0 8px 20px rgba(0, 0, 0, 0.1);
-  padding: 2rem;
-  max-width: 400px;
-  width: 100%;
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-  text-align: center;
-}
-
-.avatar {
-  margin-bottom: 1.5rem;
-}
-
-.avatarImg {
-  width: 120px;
-  height: 120px;
-  border-radius: 50%;
-  object-fit: cover;
-  border: 3px solid #4a90e2;
-}
-
-.avatarPlaceholder {
-  width: 120px;
-  height: 120px;
-  border-radius: 50%;
-  background-color: #dcdde1;
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  font-size: 3rem;
-  color: #4a4a4a;
-  font-weight: bold;
-  border: 3px solid #4a90e2;
-}
-
-.info {
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-}
-
-.name {
-  font-size: 1.8rem;
-  font-weight: 700;
-  margin: 0.25rem 0;
-  color: #2f3640;
-}
-
-.nickname {
-  font-size: 1rem;
-  color: #718093;
-  margin-bottom: 1rem;
-}
-
-.desc {
-  font-size: 1rem;
-  color: #353b48;
-  margin-bottom: 1rem;
-}
-
-.created {
-  font-size: 0.9rem;
-  color: #7f8fa6;
-}
-
-.loader {
-  display: flex;
-  justify-content: center;
-  align-items: center;
-  height: 80vh;
-  font-size: 1.5rem;
-  color: #4a90e2;
-}
-
-.error {
-  display: flex;
-  justify-content: center;
-  align-items: center;
-  height: 80vh;
-  color: #e84118;
-  font-weight: 600;
-  font-size: 1.2rem;
-}

modules/frontend/src/components/UserPage/UserPage.tsx

@@ -1,64 +0,0 @@
-import React, { useEffect, useState } from "react";
-import { useParams } from "react-router-dom"; // <-- import
-import { DefaultService } from "../../api/services/DefaultService";
-import type { User } from "../../api/models/User";
-import styles from "./UserPage.module.css";
-
-const UserPage: React.FC = () => {
-  const { id } = useParams<{ id: string }>(); // <-- get user id from URL
-  const [user, setUser] = useState<User | null>(null);
-  const [loading, setLoading] = useState(true);
-  const [error, setError] = useState<string | null>(null);
-
-  useEffect(() => {
-    if (!id) return;
-
-    const getUserInfo = async () => {
-      try {
-        const userInfo = await DefaultService.getUsers(id, "all"); // <-- use dynamic id
-        setUser(userInfo);
-      } catch (err) {
-        console.error(err);
-        setError("Failed to fetch user info.");
-      } finally {
-        setLoading(false);
-      }
-    };
-    getUserInfo();
-  }, [id]);
-
-  if (loading) return <div className={styles.loader}>Loading...</div>;
-  if (error) return <div className={styles.error}>{error}</div>;
-  if (!user) return <div className={styles.error}>User not found.</div>;
-
-  return (
-    <div className={styles.container}>
-      <div className={styles.card}>
-        <div className={styles.avatar}>
-          {user.avatar_id ? (
-            <img
-              src={`/images/${user.avatar_id}.png`}
-              alt="User Avatar"
-              className={styles.avatarImg}
-            />
-          ) : (
-            <div className={styles.avatarPlaceholder}>
-              {user.disp_name?.[0] || "U"}
-            </div>
-          )}
-        </div>
-
-        <div className={styles.info}>
-          <h1 className={styles.name}>{user.disp_name || user.nickname}</h1>
-          <p className={styles.nickname}>@{user.nickname}</p>
-          {user.user_desc && <p className={styles.desc}>{user.user_desc}</p>}
-          <p className={styles.created}>
-            Joined: {new Date(user.creation_date).toLocaleDateString()}
-          </p>
-        </div>
-      </div>
-    </div>
-  );
-};
-
-export default UserPage;

modules/frontend/src/components/cards/TitleCardHorizontal.tsx

@@ -0,0 +1,22 @@
+import type { Title } from "../../api";
+
+export function TitleCardHorizontal({ title }: { title: Title }) {
+  return (
+    <div style={{
+      display: "flex",
+      gap: 12,
+      padding: 12,
+      border: "1px solid #ddd",
+      borderRadius: 8
+    }}>
+      {title.poster?.image_path && (
+        <img src={title.poster.image_path} width={80} />
+      )}
+      <div>
+        <h3>{title.title_names["en"]}</h3>
+        <p>{title.release_year} · {title.release_season} · Rating: {title.rating}</p>
+        <p>Status: {title.title_status}</p>
+      </div>
+    </div>
+  );
+}

modules/frontend/src/components/cards/TitleCardSquare.tsx

@@ -0,0 +1,21 @@
+import type { Title } from "../../api";
+
+export function TitleCardSquare({ title }: { title: Title }) {
+  return (
+    <div style={{
+      width: 160,
+      border: "1px solid #ddd",
+      padding: 8,
+      borderRadius: 8,
+      textAlign: "center"
+    }}>
+      {title.poster?.image_path && (
+        <img src={title.poster.image_path} width={140} />
+      )}
+      <div>
+        <h4>{title.title_names["en"]}</h4>
+        <small>{title.release_year} • {title.rating}</small>
+      </div>
+    </div>
+  );
+}

modules/frontend/src/components/cards/UserTitleCardHorizontal.tsx

@@ -0,0 +1,22 @@
+import type { UserTitle } from "../../api";
+
+export function UserTitleCardHorizontal({ title }: { title: UserTitle }) {
+  return (
+    <div style={{
+      display: "flex",
+      gap: 12,
+      padding: 12,
+      border: "1px solid #ddd",
+      borderRadius: 8
+    }}>
+      {title.title?.poster?.image_path && (
+        <img src={title.title?.poster.image_path} width={80} />
+      )}
+      <div>
+        <h3>{title.title?.title_names["en"]}</h3>
+        <p>{title.title?.release_year} · {title.title?.release_season} · Rating: {title.title?.rating}</p>
+        <p>Status: {title.title?.title_status}</p>
+      </div>
+    </div>
+  );
+}

modules/frontend/src/components/cards/UserTitleCardSquare.tsx

@@ -0,0 +1,22 @@
+import type { UserTitle } from "../../api";
+
+export function UserTitleCardSquare({ title }: { title: UserTitle }) {
+  return (
+    <div style={{
+      width: 160,
+      border: "1px solid #ddd",
+      padding: 8,
+      borderRadius: 8,
+      textAlign: "center"
+    }}>
+      {title.title?.poster?.image_path && (
+        <img src={title.title?.poster.image_path} width={140} />
+      )}
+      <div>
+        <h4>{title.title?.title_names["en"]}</h4>
+        <h5>{title.status}</h5>
+        <small>{title.title?.release_year} • {title.title?.rating}</small>
+      </div>
+    </div>
+  );
+}

modules/frontend/src/index.css

@@ -1,68 +1,9 @@
-:root {
-  font-family: system-ui, Avenir, Helvetica, Arial, sans-serif;
-  line-height: 1.5;
-  font-weight: 400;
+@import "tailwindcss";
 
-  color-scheme: light dark;
-  color: rgba(255, 255, 255, 0.87);
-  background-color: #242424;
-
-  font-synthesis: none;
-  text-rendering: optimizeLegibility;
-  -webkit-font-smoothing: antialiased;
-  -moz-osx-font-smoothing: grayscale;
-}
-
-a {
-  font-weight: 500;
-  color: #646cff;
-  text-decoration: inherit;
-}
-a:hover {
-  color: #535bf2;
-}
-
-body {
+html, body, #root {
   margin: 0;
-  display: flex;
-  place-items: center;
-  min-width: 320px;
-  min-height: 100vh;
-}
-
-h1 {
-  font-size: 3.2em;
-  line-height: 1.1;
-}
-
-button {
-  border-radius: 8px;
-  border: 1px solid transparent;
-  padding: 0.6em 1.2em;
-  font-size: 1em;
-  font-weight: 500;
-  font-family: inherit;
-  background-color: #1a1a1a;
-  cursor: pointer;
-  transition: border-color 0.25s;
-}
-button:hover {
-  border-color: #646cff;
-}
-button:focus,
-button:focus-visible {
-  outline: 4px auto -webkit-focus-ring-color;
-}
-
-@media (prefers-color-scheme: light) {
-  :root {
-    color: #213547;
-    background-color: #ffffff;
-  }
-  a:hover {
-    color: #747bff;
-  }
-  button {
-    background-color: #f9f9f9;
-  }
-}
+  padding: 0;
+  width: 100%;
+  height: 100%;
+  @apply text-black bg-white;
+}

modules/frontend/src/main.tsx

@@ -1,10 +1,13 @@
 import { StrictMode } from 'react'
 import { createRoot } from 'react-dom/client'
+import { CookiesProvider } from 'react-cookie'
 import './index.css'
 import App from './App.tsx'
 
 createRoot(document.getElementById('root')!).render(
   <StrictMode>
-    <App />
+    <CookiesProvider>
+      <App />
+    </CookiesProvider>
   </StrictMode>,
 )

modules/frontend/src/pages/LoginPage/LoginPage.tsx

@@ -0,0 +1,118 @@
+import React, { useState } from "react";
+import { AuthService } from "../../auth/services/AuthService";
+import { useNavigate } from "react-router-dom";
+
+export const LoginPage: React.FC = () => {
+  const navigate = useNavigate();
+  const [isLogin, setIsLogin] = useState(true); // true = login, false = signup
+  const [nickname, setNickname] = useState("");
+  const [password, setPassword] = useState("");
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  const handleSubmit = async (e: React.FormEvent) => {
+    e.preventDefault();
+    setLoading(true);
+    setError(null);
+
+    try {
+      if (isLogin) {
+        const res = await AuthService.postSignIn({ nickname, pass: password });
+        if (res.user_id && res.user_name) {
+          // Сохраняем user_id и username в localStorage
+          localStorage.setItem("userId", res.user_id.toString());
+          localStorage.setItem("username", res.user_name);
+
+          navigate("/profile"); // редирект на профиль
+        } else {
+          setError("Login failed");
+        }
+      } else {
+        // SignUp оставляем без сохранения данных
+        const res = await AuthService.postSignUp({ nickname, pass: password });
+        if (res.user_id) {
+          setIsLogin(true); // переключаемся на login после регистрации
+        } else {
+          setError("Sign up failed");
+        }
+      }
+    } catch (err: any) {
+      console.error(err);
+      setError(err?.message || "Something went wrong");
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  return (
+    <div className="min-h-screen flex items-center justify-center bg-gray-50 px-4">
+      <div className="max-w-md w-full bg-white shadow-md rounded-lg p-8">
+        <h2 className="text-2xl font-bold mb-6 text-center">
+          {isLogin ? "Login" : "Sign Up"}
+        </h2>
+
+        {error && <div className="text-red-600 mb-4">{error}</div>}
+
+        <form onSubmit={handleSubmit} className="space-y-4">
+          <div>
+            <label className="block text-sm font-medium text-gray-700 mb-1">
+              Nickname
+            </label>
+            <input
+              type="text"
+              value={nickname}
+              onChange={(e) => setNickname(e.target.value)}
+              className="w-full px-4 py-2 border border-gray-300 rounded-lg focus:outline-none focus:ring-2 focus:ring-blue-500"
+              required
+            />
+          </div>
+
+          <div>
+            <label className="block text-sm font-medium text-gray-700 mb-1">
+              Password
+            </label>
+            <input
+              type="password"
+              value={password}
+              onChange={(e) => setPassword(e.target.value)}
+              className="w-full px-4 py-2 border border-gray-300 rounded-lg focus:outline-none focus:ring-2 focus:ring-blue-500"
+              required
+            />
+          </div>
+
+          <button
+            type="submit"
+            disabled={loading}
+            className="w-full bg-blue-600 text-white py-2 rounded-lg font-semibold hover:bg-blue-700 transition disabled:opacity-50"
+          >
+            {loading ? "Please wait..." : isLogin ? "Login" : "Sign Up"}
+          </button>
+        </form>
+
+        <div className="mt-4 text-center text-sm text-gray-600">
+          {isLogin ? (
+            <>
+              Don't have an account?{" "}
+              <button
+                onClick={() => setIsLogin(false)}
+                className="text-blue-600 hover:underline"
+              >
+                Sign Up
+              </button>
+            </>
+          ) : (
+            <>
+              Already have an account?{" "}
+              <button
+                onClick={() => setIsLogin(true)}
+                className="text-blue-600 hover:underline"
+              >
+                Login
+              </button>
+            </>
+          )}
+        </div>
+      </div>
+    </div>
+  );
+};

modules/frontend/src/pages/TitlePage/TitlePage.tsx

@@ -0,0 +1,109 @@
+import { useEffect, useState } from "react";
+import { useParams, Link } from "react-router-dom";
+// import { DefaultService } from "../../api/services/DefaultService";
+import { getTitle, type Title } from "../../api";
+import { TitleStatusControls } from "../../components/TitleStatusControls/TitleStatusControls";
+
+export default function TitlePage() {
+  const params = useParams();
+  const titleId = Number(params.id);
+
+  const [title, setTitle] = useState<Title | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+
+  // ---------------------------
+  //       LOAD TITLE INFO
+  // ---------------------------
+  useEffect(() => {
+    const fetchTitle = async () => {
+      setLoading(true);
+      try {
+        // const data = await DefaultService.getTitle(titleId, "all");
+        const data = await getTitle({path: {title_id: titleId}})
+        setTitle(data?.data ?? null);
+        setError(null);
+      } catch (err: any) {
+        console.error(err);
+        setError(err?.message || "Failed to fetch title");
+      } finally {
+        setLoading(false);
+      }
+    };
+    fetchTitle();
+  }, [titleId]);
+
+  const getTagsString = () =>
+    title?.tags?.map(tag => tag.en).filter(Boolean).join(", ");
+
+  if (loading) return <div className="mt-20 font-medium text-black">Loading title...</div>;
+  if (error) return <div className="mt-20 text-red-600 font-medium">{error}</div>;
+  if (!title) return null;
+
+  return (
+    <div className="w-full min-h-screen bg-gray-50 p-6 flex justify-center">
+      <div className="flex flex-col md:flex-row bg-white shadow-lg rounded-xl max-w-4xl w-full p-6 gap-6">
+        {/* Poster + status buttons */}
+        <div className="flex flex-col items-center">
+          <img
+            src={title.poster?.image_path || "/default-poster.png"}
+            alt={title.title_names?.en?.[0] || "Title poster"}
+            className="w-48 h-72 object-cover rounded-lg mb-4"
+          />
+
+          {/* Status buttons */}
+          <TitleStatusControls titleId={titleId} />
+        </div>
+
+        {/* Title info */}
+        <div className="flex-1 flex flex-col">
+          <h1 className="text-3xl font-bold mb-2">
+            {title.title_names?.en?.[0] || "Untitled"}
+          </h1>
+
+          {title.studio && (
+            <p className="text-gray-700 mb-1">
+              Studio:{" "}
+              {title.studio.id ? (
+                <Link
+                  to={`/studios/${title.studio.id}`}
+                  className="text-blue-600 hover:underline"
+                >
+                  {title.studio.name}
+                </Link>
+              ) : (
+                title.studio.name
+              )}
+            </p>
+          )}
+
+          {title.title_status && <p className="text-gray-700 mb-1">Status: {title.title_status}</p>}
+
+          {title.rating !== undefined && (
+            <p className="text-gray-700 mb-1">
+              Rating: {title.rating} ({title.rating_count} votes)
+            </p>
+          )}
+
+          {title.release_year && (
+            <p className="text-gray-700 mb-1">
+              Released: {title.release_year} {title.release_season || ""}
+            </p>
+          )}
+
+          {title.episodes_aired !== undefined && (
+            <p className="text-gray-700 mb-1">
+              Episodes: {title.episodes_aired}/{title.episodes_all}
+            </p>
+          )}
+
+          {title.tags && title.tags.length > 0 && (
+            <p className="text-gray-700 mb-1">
+              Tags: {getTagsString()}
+            </p>
+          )}
+        </div>
+      </div>
+    </div>
+  );
+}

modules/frontend/src/pages/TitlesPage/TitlesPage.tsx

@@ -0,0 +1,160 @@
+import { useEffect, useState } from "react";
+import { ListView } from "../../components/ListView/ListView";
+import { SearchBar } from "../../components/SearchBar/SearchBar";
+import { TitlesSortBox } from "../../components/TitlesSortBox/TitlesSortBox";
+// import { DefaultService } from "../../api/services/DefaultService";
+import { TitleCardSquare } from "../../components/cards/TitleCardSquare";
+import { TitleCardHorizontal } from "../../components/cards/TitleCardHorizontal";
+import { getTitles, type CursorObj, type Title, type TitleSort } from "../../api";
+import { LayoutSwitch } from "../../components/LayoutSwitch/LayoutSwitch";
+import { Link } from "react-router-dom";
+import { type TitlesFilter, TitlesFilterPanel } from "../../components/TitlesFilterPanel/TitlesFilterPanel";
+
+const PAGE_SIZE = 10;
+
+export default function TitlesPage() {
+  const [titles, setTitles] = useState<Title[]>([]);
+  const [nextPage, setNextPage] = useState<Title[]>([]);
+  const [cursor, setCursor] = useState<CursorObj | null>(null);
+  const [search, setSearch] = useState("");
+  const [loading, setLoading] = useState(true);
+  const [loadingMore, setLoadingMore] = useState(false);
+  const [sort, setSort] = useState<TitleSort>("id");
+  const [sortForward, setSortForward] = useState(true);
+  const [layout, setLayout] = useState<"square" | "horizontal">("square");
+
+  const [filters, setFilters] = useState<TitlesFilter>({
+    extSearch: false,
+    status: "",
+    rating: "",
+    releaseYear: "",
+    releaseSeason: "",
+  });
+
+  const fetchPage = async (cursorObj: CursorObj | null) => {
+    const cursorStr = cursorObj
+      ? btoa(JSON.stringify(cursorObj)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "")
+      : undefined;
+
+    const response = await getTitles({
+      query: {
+        cursor: cursorStr,
+        sort: sort,
+        sort_forward: sortForward,
+        ext_search: filters.extSearch,
+        word: search.trim() || undefined,
+        status: filters.status ? [filters.status] : undefined,
+        rating: filters.rating || undefined,
+        release_year: filters.releaseYear || undefined,
+        release_season: filters.releaseSeason || undefined,
+        limit: PAGE_SIZE,
+        offset: PAGE_SIZE,
+        fields: "all",
+      },
+    });
+
+    return {
+      items: response.data?.data ?? [],
+      nextCursor: response.data?.cursor ?? null,
+    };
+  };
+
+  // Инициализация: загружаем сразу две страницы
+  useEffect(() => {
+    const initLoad = async () => {
+      setLoading(true);
+      setTitles([]);
+      setNextPage([]);
+      setCursor(null);
+
+      const firstPage = await fetchPage(null);
+      const secondPage = firstPage.nextCursor ? await fetchPage(firstPage.nextCursor) : { items: [], nextCursor: null };
+
+      setTitles(firstPage.items);
+      setNextPage(secondPage.items);
+      setCursor(secondPage.nextCursor);
+      setLoading(false);
+    };
+
+    initLoad();
+  }, [search, sort, sortForward, filters]);
+
+
+const handleLoadMore = async () => {
+  if (nextPage.length === 0) {
+    setLoadingMore(false);
+    return;
+  }
+
+  setLoadingMore(true);
+
+  setTitles(prev => [...prev, ...nextPage]);
+  setNextPage([]);
+
+  // Подгружаем следующую страницу с сервера
+  if (cursor) {
+    try {
+      const next = await fetchPage(cursor);
+      if (next.items.length > 0) {
+        setNextPage(next.items);
+      }
+      setCursor(next.nextCursor);
+    } catch (err) {
+      console.error(err);
+    }
+  }
+
+  // Любой сценарий – выключаем loadingMore
+  setLoadingMore(false);
+};
+
+
+
+  return (
+    <div className="w-full min-h-screen bg-gray-50 p-6 flex flex-col items-center">
+
+      <h1 className="text-4xl font-bold mb-6 text-center text-black">Titles</h1>
+
+      <div className="w-full sm:w-4/5 flex flex-col sm:flex-row gap-4 mb-6 items-center">
+        <SearchBar placeholder="Search titles..." search={search} setSearch={setSearch} />
+        <LayoutSwitch layout={layout} setLayout={setLayout} />
+        <TitlesSortBox
+          sort={sort}
+          setSort={setSort}
+          sortForward={sortForward}
+          setSortForward={setSortForward}
+        />
+      </div>
+       <TitlesFilterPanel filters={filters} setFilters={setFilters} />
+
+      {loading && <div className="mt-20 font-medium text-black">Loading...</div>}
+
+      {!loading && titles.length === 0 && (
+        <div className="mt-20 font-medium text-black">No titles found.</div>
+      )}
+
+      {titles.length > 0 && (
+        <>
+          <ListView<Title>
+            items={titles}
+            layout={layout}
+            hasMore={!!cursor || nextPage.length > 1}
+            loadingMore={loadingMore}
+            onLoadMore={handleLoadMore}
+            renderItem={(title, layout) => (
+              <Link to={`/titles/${title.id}`} key={title.id} className="block">
+                {layout === "square" ? <TitleCardSquare title={title} /> : <TitleCardHorizontal title={title} />}
+              </Link>
+            )}
+          />
+
+          {!cursor && nextPage.length == 0 && (
+            <div className="mt-6 font-medium text-black">
+              Результатов больше нет, было найдено {titles.length} тайтлов.
+            </div>
+          )}
+        </>
+      )}
+    </div>
+  );
+}

modules/frontend/src/pages/UserPage/UserPage.tsx

@@ -0,0 +1,201 @@
+// pages/UserPage/UserPage.tsx
+import { useEffect, useState } from "react";
+import { useParams } from "react-router-dom";
+// import { DefaultService } from "../../api/services/DefaultService";
+import { SearchBar } from "../../components/SearchBar/SearchBar";
+import { TitlesSortBox } from "../../components/TitlesSortBox/TitlesSortBox";
+import { LayoutSwitch } from "../../components/LayoutSwitch/LayoutSwitch";
+import { ListView } from "../../components/ListView/ListView";
+import { UserTitleCardSquare } from "../../components/cards/UserTitleCardSquare";
+import { UserTitleCardHorizontal } from "../../components/cards/UserTitleCardHorizontal";
+import { type User, type UserTitle, type CursorObj, type TitleSort, getUsersId, getUserTitles } from "../../api";
+import { Link } from "react-router-dom";
+
+const PAGE_SIZE = 10;
+
+type UserPageProps = {
+  userId?: string;
+};
+
+export default function UserPage({ userId }: UserPageProps) {
+  const params = useParams();
+  const id = userId || params?.id;
+
+  const [user, setUser] = useState<User | null>(null);
+  const [loadingUser, setLoadingUser] = useState(true);
+  const [errorUser, setErrorUser] = useState<string | null>(null);
+
+  // Для списка тайтлов
+  const [titles, setTitles] = useState<UserTitle[]>([]);
+  const [nextPage, setNextPage] = useState<UserTitle[]>([]);
+  const [cursor, setCursor] = useState<CursorObj | null>(null);
+  const [loadingTitles, setLoadingTitles] = useState(true);
+  const [loadingMore, setLoadingMore] = useState(false);
+  const [search, setSearch] = useState("");
+  const [sort, setSort] = useState<TitleSort>("id");
+  const [sortForward, setSortForward] = useState(true);
+  const [layout, setLayout] = useState<"square" | "horizontal">("square");
+
+  // --- Получение данных пользователя ---
+  useEffect(() => {
+    const fetchUser = async () => {
+      if (!id) return;
+      setLoadingUser(true);
+      try {
+        // const result = await DefaultService.getUsersId(id, "all");
+        const result = await getUsersId({path: {user_id: id}})
+        setUser(result?.data ?? null);
+        setErrorUser(null);
+      } catch (err: any) {
+        console.error(err);
+        setErrorUser(err?.message || "Failed to fetch user data");
+      } finally {
+        setLoadingUser(false);
+      }
+    };
+    fetchUser();
+  }, [id]);
+
+  // --- Получение списка тайтлов пользователя ---
+  const fetchPage = async (cursorObj: CursorObj | null) => {
+    if (!id) return { items: [], nextCursor: null };
+    const cursorStr = cursorObj
+      ? btoa(JSON.stringify(cursorObj)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "")
+      : "";
+
+    try {
+      const result = await getUserTitles({
+          path: {
+              user_id: id,
+          },
+          query: {
+              cursor: cursorStr,
+              sort: sort,
+              sort_forward: sortForward,
+              word: search.trim() || undefined,
+              status: undefined,
+              watch_status: undefined,
+              rating: undefined,
+              my_rate: undefined,
+              release_year: undefined,
+              release_season: undefined,
+              limit: PAGE_SIZE}})
+      // const result = await DefaultService.getUserTitles(
+      //   id,
+      //   cursorStr,
+      //   sort,
+      //   sortForward,
+      //   search.trim() || undefined,
+      //   undefined, // status фильтр, можно добавить
+      //   undefined, // watchStatus
+      //   undefined, // rating
+      //   undefined, // myRate
+      //   undefined, // releaseYear
+      //   undefined, // releaseSeason
+      //   PAGE_SIZE,
+      //   "all"
+      // );
+
+      if (!result?.data?.data?.length) return { items: [], nextCursor: null };
+
+      return { items: result.data?.data, nextCursor: result.data?.cursor ?? null };
+    } catch (err: any) {
+      if (err.status === 204) return { items: [], nextCursor: null };
+      throw err;
+    }
+  };
+
+  // Инициализация: загружаем сразу две страницы
+  useEffect(() => {
+    const initLoad = async () => {
+      setLoadingTitles(true);
+      setTitles([]);
+      setNextPage([]);
+      setCursor(null);
+
+      const firstPage = await fetchPage(null);
+      const secondPage = firstPage.nextCursor ? await fetchPage(firstPage.nextCursor) : { items: [], nextCursor: null };
+
+      setTitles(firstPage.items);
+      setNextPage(secondPage.items);
+      setCursor(secondPage.nextCursor);
+      setLoadingTitles(false);
+    };
+    initLoad();
+  }, [id, search, sort, sortForward]);
+
+  const handleLoadMore = async () => {
+    if (nextPage.length === 0) {
+      setLoadingMore(false);
+      return;
+    }
+    setLoadingMore(true);
+
+    setTitles(prev => [...prev, ...nextPage]);
+    setNextPage([]);
+
+    if (cursor) {
+      try {
+        const next = await fetchPage(cursor);
+        if (next.items.length > 0) setNextPage(next.items);
+        setCursor(next.nextCursor);
+      } catch (err) {
+        console.error(err);
+      }
+    }
+
+    setLoadingMore(false);
+  };
+
+  return (
+    <div className="w-full min-h-screen bg-gray-50 p-6 flex flex-col items-center">
+
+      {/* --- Карточка пользователя --- */}
+      {loadingUser && <div className="mt-10 text-xl font-medium">Loading user...</div>}
+      {errorUser && <div className="mt-10 text-red-600 font-medium">{errorUser}</div>}
+      {user && (
+        <div className="bg-white shadow-lg rounded-xl p-6 w-full max-w-sm flex flex-col items-center mb-8">
+          <img src={user.image?.image_path} alt={user.nickname} className="w-32 h-32 rounded-full object-cover mb-4" />
+          <h2 className="text-2xl font-bold mb-2">{user.disp_name || user.nickname}</h2>
+          {user.mail && <p className="text-gray-600 mb-2">{user.mail}</p>}
+          {user.user_desc && <p className="text-gray-700 text-center">{user.user_desc}</p>}
+          {user.creation_date && <p className="text-gray-400 mt-4 text-sm">Registered: {new Date(user.creation_date).toLocaleDateString()}</p>}
+        </div>
+      )}
+
+      {/* --- Панель поиска, сортировки и лейаута --- */}
+      <div className="w-full sm:w-4/5 flex flex-col sm:flex-row gap-4 mb-6 items-center">
+        <SearchBar placeholder="Search titles..." search={search} setSearch={setSearch} />
+        <LayoutSwitch layout={layout} setLayout={setLayout} />
+        <TitlesSortBox sort={sort} setSort={setSort} sortForward={sortForward} setSortForward={setSortForward} />
+      </div>
+
+      {/* --- Список тайтлов --- */}
+      {loadingTitles && <div className="mt-6 font-medium text-black">Loading titles...</div>}
+      {!loadingTitles && titles.length === 0 && <div className="mt-6 font-medium text-black">No titles found.</div>}
+
+      {titles.length > 0 && (
+        <>
+          <ListView<UserTitle>
+            items={titles}
+            layout={layout}
+            hasMore={!!cursor || nextPage.length > 1}
+            loadingMore={loadingMore}
+            onLoadMore={handleLoadMore}
+            renderItem={(title, layout) => (
+              <Link to={`/titles/${title.title?.id}`} key={title.title?.id} className="block">
+                {layout === "square" ? <UserTitleCardSquare title={title} /> : <UserTitleCardHorizontal title={title} />}
+              </Link>
+            )}
+          />
+
+          {!cursor && nextPage.length === 0 && (
+            <div className="mt-6 font-medium text-black">
+              Результатов больше нет, было найдено {titles.length} тайтлов.
+            </div>
+          )}
+        </>
+      )}
+    </div>
+  );
+}

modules/frontend/src/types/list.ts

@@ -0,0 +1,12 @@
+export interface PaginatedResult<TItem> {
+  items: TItem[];
+  nextCursor?: string;
+}
+
+export interface FetchParams {
+  search: string;
+  cursor?: string;
+}
+
+export type FetchFunction<TItem> =
+  (params: FetchParams) => Promise<PaginatedResult<TItem>>;

modules/frontend/tsconfig.app.json

@@ -20,7 +20,7 @@
     "strict": true,
     "noUnusedLocals": true,
     "noUnusedParameters": true,
-    "erasableSyntaxOnly": true,
+    "erasableSyntaxOnly": false,
     "noFallthroughCasesInSwitch": true,
     "noUncheckedSideEffectImports": true
   },

modules/frontend/tsconfig.node.json

@@ -18,7 +18,7 @@
     "strict": true,
     "noUnusedLocals": true,
     "noUnusedParameters": true,
-    "erasableSyntaxOnly": true,
+    "erasableSyntaxOnly": false,
     "noFallthroughCasesInSwitch": true,
     "noUncheckedSideEffectImports": true
   },

modules/frontend/vite.config.ts

@@ -1,11 +1,15 @@
 import { defineConfig } from 'vite'
 import react from '@vitejs/plugin-react'
+import tailwindcss from '@tailwindcss/vite'
 
 // https://vite.dev/config/
 export default defineConfig({
-  plugins: [react()],
+  plugins: [
+    react(), 
+    tailwindcss()
+  ],
   server: {
-    host: '127.0.0.1',
+    host: '0.0.0.0',
     port: 8083,
   },
 })