rewrite competition service: remove http related things

internal/competition/server/server.go

@@ -4,11 +4,11 @@ import (
 	"fmt"
 	"log"
 	"net"
-	"net/http"
 	"time"
 
 	"datarush/internal/competition/config"
 	grpcHandlers "datarush/internal/competition/handler/grpc"
+	"datarush/internal/competition/middleware"
 	"datarush/internal/competition/repository/postgres"
 	"datarush/internal/competition/service"
 	pb "datarush/pkg/api/competition"
@@ -27,7 +27,6 @@ const (
 
 type Server struct {
 	grpcServer *grpc.Server
-	httpServer *http.Server
 	config     *config.Config
 	db         *sqlx.DB
 }
@@ -45,32 +44,32 @@ func (s *Server) Start() error {
 	}
 	s.db = db
 
+	if err := s.registerGRPCServices(); err != nil {
+		return fmt.Errorf("failed to register gRPC services: %w", err)
+	}
+
 	go func() {
-		if err := s.startGRPCServer(); err != nil {
-			log.Fatalf("failed to start gRPC server: %v", err)
+		lis, err := net.Listen("tcp", fmt.Sprintf(":%d", s.config.GRPCPort))
+		if err != nil {
+			log.Fatalf("failed to listen on grpc port: %v", err)
+		}
+
+		log.Printf("starting gRPC server on port %d", s.config.GRPCPort)
+		if err := s.grpcServer.Serve(lis); err != nil {
+			log.Fatalf("failed to serve gRPC: %v", err)
 		}
 	}()
 
-	log.Println("competition service started")
 	return nil
 }
 
-func (s *Server) startGRPCServer() error {
-	lis, err := net.Listen("tcp", fmt.Sprintf(":%d", s.config.GRPCPort))
-	if err != nil {
-		return fmt.Errorf("failed to listen on grpc port: %w", err)
-	}
+func (s *Server) registerGRPCServices() error {
+	s.grpcServer = grpc.NewServer(
+		grpc.UnaryInterceptor(middleware.AuthInterceptor(s.config.JWTSecret)),
+	)
 
-	s.grpcServer = grpc.NewServer()
-	s.registerGRPCServices()
-
-	log.Printf("starting gRPC server on port %d", s.config.GRPCPort)
-	return s.grpcServer.Serve(lis)
-}
-
-func (s *Server) registerGRPCServices() {
-	compRepo := postgres.NewCompetitionRepository(s.db.DB, nil, false)
-	compService := service.NewService(compRepo)
+	compRepo := postgres.NewCompetitionRepository(s.db)
+	compService := service.NewCompetitionService(compRepo)
 	compHandler := grpcHandlers.NewCompetitionHandler(compService)
 
 	pb.RegisterCompetitionServiceServer(s.grpcServer, compHandler)
@@ -78,6 +77,8 @@ func (s *Server) registerGRPCServices() {
 	if s.config.GRPCEnableReflection {
 		reflection.Register(s.grpcServer)
 	}
+
+	return nil
 }
 
 func (s *Server) Stop() {
@@ -89,9 +90,9 @@ func (s *Server) Stop() {
 
 	if s.db != nil {
 		if err := s.db.Close(); err != nil {
-			log.Printf("failed to close database connection: %v", err)
+			log.Printf("failed to close database: %v", err)
 		}
 	}
 
 	log.Println("competition server stopped")
-}
+}