[server] add user-related endpoints

Author: capcom6

internal/server/admin/users/dto.go

@@ -0,0 +1,70 @@
+package users
+
+import (
+	"time"
+
+	"github.com/bit-issues/backend/internal/users"
+)
+
+const (
+	defaultLimit = 20
+)
+
+// AdminUserFilter represents query parameters for filtering users.
+//
+//	@Description	Query parameters for filtering and paginating users list.
+type AdminUserFilter struct {
+	Status *users.Status `query:"status" validate:"omitempty,oneof=pending active blocked" enums:"pending,active,blocked"`
+	Role   *users.Role   `query:"role"   validate:"omitempty,oneof=admin user"             enums:"admin,user"`
+	Limit  int           `query:"limit"  validate:"min=1,max=100"                                                         default:"20"`
+	Offset int           `query:"offset" validate:"min=0"                                                                 default:"0"`
+}
+
+// UpdateUserRequest represents admin request to update user status/role.
+//
+//	@Description	Admin can update user status (active/blocked/pending) and role (admin/user).
+type UpdateUserRequest struct {
+	Status *users.Status `json:"status,omitempty" validate:"omitempty,oneof=pending active blocked" enums:"pending,active,blocked"`
+	Role   *users.Role   `json:"role,omitempty"   validate:"omitempty,oneof=admin user"             enums:"admin,user"`
+}
+
+// UserResponse represents user data in admin responses (without password).
+//
+//	@Description	User data returned in admin API responses (password excluded).
+type UserResponse struct {
+	ID        int64        `json:"id"         example:"42"`
+	Email     string       `json:"email"      example:"user@example.com"`
+	Role      users.Role   `json:"role"       example:"user"                 enums:"admin,user"`
+	Status    users.Status `json:"status"     example:"active"               enums:"pending,active,blocked"`
+	CreatedAt time.Time    `json:"created_at" example:"2026-04-06T10:00:00Z"`
+	UpdatedAt time.Time    `json:"updated_at" example:"2026-04-06T10:00:00Z"`
+}
+
+// UserListResponse represents paginated list of users.
+//
+//	@Description	Paginated response containing users list and total count.
+type UserListResponse struct {
+	Items []UserResponse `json:"items"`
+	Total int            `json:"total" example:"42"`
+}
+
+func defaultAdminUserFilter() AdminUserFilter {
+	return AdminUserFilter{
+		Status: nil,
+		Role:   nil,
+		Limit:  defaultLimit,
+		Offset: 0,
+	}
+}
+
+// toUserResponse converts domain User to admin UserResponse.
+func toUserResponse(u *users.User) UserResponse {
+	return UserResponse{
+		ID:        u.ID,
+		Email:     u.Email,
+		Role:      u.Role,
+		Status:    u.Status,
+		CreatedAt: u.CreatedAt,
+		UpdatedAt: u.UpdatedAt,
+	}
+}

internal/server/admin/users/handler.go

@@ -0,0 +1,167 @@
+package users
+
+import (
+	"errors"
+	"fmt"
+	"strconv"
+
+	"github.com/bit-issues/backend/internal/jwt"
+	"github.com/bit-issues/backend/internal/server/middlewares/jwtauth"
+	"github.com/bit-issues/backend/internal/users"
+	"github.com/go-core-fx/fiberfx/handler"
+	"github.com/go-core-fx/fiberfx/validation"
+	"github.com/go-playground/validator/v10"
+	"github.com/gofiber/fiber/v2"
+)
+
+type Handler struct {
+	handler.Base
+
+	usersSvc *users.Service
+
+	jwtSvc *jwt.Service
+}
+
+func NewHandler(usersSvc *users.Service, jwtSvc *jwt.Service, validate *validator.Validate) handler.Handler {
+	return &Handler{
+		Base: handler.Base{Validator: validate},
+
+		usersSvc: usersSvc,
+
+		jwtSvc: jwtSvc,
+	}
+}
+
+func (h *Handler) Register(r fiber.Router) {
+	admin := r.Group(
+		"/admin/users",
+		h.errorsHandler,
+		jwtauth.New(h.jwtSvc, h.usersSvc),
+		jwtauth.WithRole(users.RoleAdmin),
+	)
+
+	// GET /admin/users - list all users with optional filters
+	admin.Get("/", h.handleList)
+
+	// PATCH /admin/users/{id} - update user status/role
+	admin.Patch("/:id", validation.DecorateWithBodyEx(h.Validator, h.handleUpdate))
+}
+
+// handleList returns a paginated list of users with optional status filter.
+//
+//	@Summary		List all users
+//	@Description	Admin can list all users with optional status filter and pagination.
+//	@Tags			Admin
+//	@Accept			json
+//	@Produce		json
+//	@Security		BearerAuth
+//	@Param			status	query		users.Status			false	"Filter by status"
+//	@Param			role	query		users.Role				false	"Filter by role"
+//	@Param			limit	query		int						false	"Page limit"	default(20)
+//	@Param			offset	query		int						false	"Page offset"	default(0)
+//	@Success		200		{object}	UserListResponse		"Users list"
+//	@Failure		401		{object}	fiberfx.ErrorResponse	"Unauthorized"
+//	@Failure		403		{object}	fiberfx.ErrorResponse	"Forbidden"
+//	@Router			/admin/users [get]
+func (h *Handler) handleList(c *fiber.Ctx) error {
+	filter := defaultAdminUserFilter()
+
+	if err := h.QueryParserValidator(c, &filter); err != nil {
+		return fmt.Errorf("failed to parse query: %w", err)
+	}
+
+	// Get users from service
+	usersList, err := h.usersSvc.List(c.Context(), filter.Status, filter.Role, filter.Limit, filter.Offset)
+	if err != nil {
+		return fmt.Errorf("failed to list users: %w", err)
+	}
+
+	// Get total count for pagination
+	total, err := h.usersSvc.Count(c.Context(), filter.Status, filter.Role)
+	if err != nil {
+		return fmt.Errorf("failed to count users: %w", err)
+	}
+
+	// Convert to response DTOs
+	items := make([]UserResponse, 0, len(usersList))
+	for _, u := range usersList {
+		items = append(items, toUserResponse(&u))
+	}
+
+	return c.JSON(UserListResponse{
+		Items: items,
+		Total: int(total),
+	})
+}
+
+// handleUpdate updates user status and/or role by admin.
+//
+//	@Summary		Update user
+//	@Description	Admin can update user status (active/blocked/pending) and role (admin/user).
+//	@Tags			Admin
+//	@Accept			json
+//	@Produce		json
+//	@Security		BearerAuth
+//	@Param			id		path		int64					true	"User ID"
+//	@Param			request	body		UpdateUserRequest		true	"Update data"
+//	@Success		200		{object}	UserResponse			"Updated user"
+//	@Failure		400		{object}	fiberfx.ErrorResponse	"Validation error"
+//	@Failure		401		{object}	fiberfx.ErrorResponse	"Unauthorized"
+//	@Failure		403		{object}	fiberfx.ErrorResponse	"Forbidden"
+//	@Failure		404		{object}	fiberfx.ErrorResponse	"User not found"
+//	@Router			/admin/users/{id} [patch]
+func (h *Handler) handleUpdate(c *fiber.Ctx, req *UpdateUserRequest) error {
+	// Parse user ID from path
+	idStr := c.Params("id")
+	userID, err := strconv.ParseInt(idStr, 10, 64)
+	if err != nil {
+		return fiber.NewError(fiber.StatusBadRequest, "invalid user id")
+	}
+
+	// Validate at least one field is provided
+	if req.Status == nil && req.Role == nil {
+		return fiber.NewError(fiber.StatusBadRequest, "at least one of status or role must be provided")
+	}
+
+	// Perform update
+	if updErr := h.usersSvc.Update(
+		c.Context(),
+		userID,
+		users.UserUpdate{Status: req.Status, Role: req.Role},
+	); updErr != nil {
+		if errors.Is(updErr, users.ErrNotFound) {
+			return fiber.NewError(fiber.StatusNotFound, updErr.Error())
+		}
+		return fmt.Errorf("failed to update user: %w", updErr)
+	}
+
+	// Fetch updated user
+	updatedUser, err := h.usersSvc.GetByID(c.Context(), userID)
+	if err != nil {
+		return fmt.Errorf("failed to fetch updated user: %w", err)
+	}
+
+	return c.JSON(toUserResponse(updatedUser))
+}
+
+// errorsHandler converts service errors to HTTP errors.
+func (h *Handler) errorsHandler(c *fiber.Ctx) error {
+	err := c.Next()
+	if err == nil {
+		return nil
+	}
+
+	switch {
+	case errors.Is(err, users.ErrEmailAlreadyUsed):
+		return fiber.NewError(fiber.StatusConflict, err.Error())
+	case errors.Is(err, users.ErrNotFound):
+		return fiber.NewError(fiber.StatusNotFound, err.Error())
+	case errors.Is(err, users.ErrInvalidCredential):
+		return fiber.NewError(fiber.StatusUnauthorized, err.Error())
+	case errors.Is(err, users.ErrNotActive):
+		return fiber.NewError(fiber.StatusForbidden, err.Error())
+
+	default:
+		return err //nolint:wrapcheck // err is already wrapped
+	}
+}

internal/server/auth/dto.go

@@ -0,0 +1,63 @@
+package auth
+
+import (
+	"time"
+
+	"github.com/bit-issues/backend/internal/users"
+)
+
+// RegisterRequest represents user registration data.
+//
+//	@Description	User registration request with email and password.
+type RegisterRequest struct {
+	Email    string `json:"email"    validate:"required,email"`
+	Password string `json:"password" validate:"required,min=8,max=72"`
+}
+
+// LoginRequest represents user login data.
+//
+//	@Description	User login credentials.
+type LoginRequest struct {
+	Email    string `json:"email"    validate:"required,email"`
+	Password string `json:"password" validate:"required"`
+}
+
+// LoginResponse represents successful login response.
+//
+//	@Description	Successful login response containing JWT token and user info.
+type LoginResponse struct {
+	AccessToken string          `json:"access_token"`
+	User        UserResponseDTO `json:"user"`
+}
+
+// UserResponseDTO represents user data in responses (without password).
+//
+//	@Description	User data returned in API responses (password excluded).
+type UserResponseDTO struct {
+	ID        int64        `json:"id"`
+	Email     string       `json:"email"`
+	Role      users.Role   `json:"role"`
+	Status    users.Status `json:"status"`
+	CreatedAt time.Time    `json:"created_at"`
+	UpdatedAt time.Time    `json:"updated_at"`
+}
+
+// ChangePasswordRequest represents password change request.
+//
+//	@Description	Request to change user's password (requires old password for verification).
+type ChangePasswordRequest struct {
+	OldPassword string `json:"old_password" validate:"required"`
+	NewPassword string `json:"new_password" validate:"required,min=8,max=72"`
+}
+
+// toUserResponseDTO converts domain User to response DTO.
+func toUserResponseDTO(u *users.User) UserResponseDTO {
+	return UserResponseDTO{
+		ID:        u.ID,
+		Email:     u.Email,
+		Role:      u.Role,
+		Status:    u.Status,
+		CreatedAt: u.CreatedAt,
+		UpdatedAt: u.UpdatedAt,
+	}
+}