feat-be: Process 관련 API 쿼리 최적화

backend/src/main/java/com/cruru/applicant/domain/dto/ApplicantCard.java

@@ -0,0 +1,25 @@
+package com.cruru.applicant.domain.dto;
+
+import com.cruru.applicant.controller.response.ApplicantCardResponse;
+import java.time.LocalDateTime;
+
+public record ApplicantCard(
+        long id,
+
+        String name,
+
+        LocalDateTime createdAt,
+
+        Boolean isRejected,
+
+        long evaluationCount,
+
+        double averageScore,
+
+        long processId
+) {
+
+    public ApplicantCardResponse toResponse() {
+        return new ApplicantCardResponse(id, name, createdAt, isRejected, (int) evaluationCount, averageScore);
+    }
+}

backend/src/main/java/com/cruru/applicant/domain/repository/ApplicantRepository.java

@@ -1,16 +1,38 @@
 package com.cruru.applicant.domain.repository;
 
 import com.cruru.applicant.domain.Applicant;
+import com.cruru.applicant.domain.dto.ApplicantCard;
 import com.cruru.process.domain.Process;
 import java.util.List;
-import java.util.Optional;
 import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
 
 public interface ApplicantRepository extends JpaRepository<Applicant, Long> {
 
     List<Applicant> findAllByProcess(Process process);
 
     long countByProcess(Process process);
 
-    Optional<Applicant> findByEmail(String email);
+    @Query("""
+           SELECT new com.cruru.applicant.domain.dto.ApplicantCard( 
+               a.id, a.name, a.createdDate, a.isRejected, COUNT(e), COALESCE(AVG(e.score), 0.00), a.process.id
+           )
+           FROM Applicant a
+           LEFT JOIN Evaluation e ON e.applicant = a
+           WHERE a.process IN :processes
+           GROUP BY a.id, a.name, a.createdDate, a.isRejected, a.process.id
+           """)
+    List<ApplicantCard> findApplicantCardsByProcesses(@Param("processes") List<Process> processes);
+
+    @Query("""
+           SELECT new com.cruru.applicant.domain.dto.ApplicantCard(
+                      a.id, a.name, a.createdDate, a.isRejected, COUNT(e), COALESCE(AVG(e.score), 0.00), a.process.id
+                  )
+                  FROM Applicant a
+                  LEFT JOIN Evaluation e ON e.applicant = a
+                  WHERE a.process = :process
+                  GROUP BY a.id, a.name, a.createdDate, a.isRejected
+           """)
+    List<ApplicantCard> findApplicantCardsByProcess(@Param("process") Process process);
 }

backend/src/main/java/com/cruru/applicant/domain/repository/EvaluationRepository.java

@@ -8,9 +8,7 @@
 
 public interface EvaluationRepository extends JpaRepository<Evaluation, Long> {
 
-    int countByApplicantAndProcess(Applicant applicant, Process process);
-
     List<Evaluation> findAllByProcessAndApplicant(Process process, Applicant applicant);
 
-    void deleteByProcess(Process process);
+    void deleteByProcessId(long processId);
 }

backend/src/main/java/com/cruru/applicant/service/ApplicantService.java

@@ -3,9 +3,9 @@
 import com.cruru.applicant.controller.request.ApplicantCreateRequest;
 import com.cruru.applicant.controller.request.ApplicantMoveRequest;
 import com.cruru.applicant.controller.request.ApplicantUpdateRequest;
-import com.cruru.applicant.controller.response.ApplicantCardResponse;
 import com.cruru.applicant.controller.response.ApplicantResponse;
 import com.cruru.applicant.domain.Applicant;
+import com.cruru.applicant.domain.dto.ApplicantCard;
 import com.cruru.applicant.domain.repository.ApplicantRepository;
 import com.cruru.applicant.exception.ApplicantNotFoundException;
 import com.cruru.applicant.exception.badrequest.ApplicantRejectException;
@@ -95,18 +95,11 @@ public ApplicantResponse toApplicantResponse(Applicant applicant) {
         );
     }
 
-    public ApplicantCardResponse toApplicantCardResponse(
-            Applicant applicant,
-            int evaluationCount,
-            double averageScore
-    ) {
-        return new ApplicantCardResponse(
-                applicant.getId(),
-                applicant.getName(),
-                applicant.getCreatedDate(),
-                applicant.isRejected(),
-                evaluationCount,
-                averageScore
-        );
+    public List<ApplicantCard> findApplicantCards(List<Process> processes) {
+        return applicantRepository.findApplicantCardsByProcesses(processes);
+    }
+
+    public List<ApplicantCard> findApplicantCards(Process process) {
+        return applicantRepository.findApplicantCardsByProcess(process);
     }
 }

backend/src/main/java/com/cruru/applicant/service/EvaluationService.java

@@ -29,18 +29,6 @@ public void create(EvaluationCreateRequest request, Process process, Applicant a
         evaluationRepository.save(new Evaluation(request.score(), request.content(), process, applicant));
     }
 
-    public int count(Process process, Applicant applicant) {
-        return evaluationRepository.countByApplicantAndProcess(applicant, process);
-    }
-
-    public double calculateAverageScore(Process process, Applicant applicant) {
-        List<Evaluation> evaluations = findAllByProcessAndApplicant(process, applicant);
-        return evaluations.stream()
-                .mapToDouble(Evaluation::getScore)
-                .average()
-                .orElse(0.0);
-    }
-
     public List<Evaluation> findAllByProcessAndApplicant(Process process, Applicant applicant) {
         return evaluationRepository.findAllByProcessAndApplicant(process, applicant);
     }
@@ -64,7 +52,7 @@ private boolean changeExists(EvaluationUpdateRequest request, Evaluation evaluat
         return !(evaluation.getContent().equals(request.content()) && evaluation.getScore().equals(request.score()));
     }
 
-    public void deleteByProcess(Process process) {
-        evaluationRepository.deleteByProcess(process);
+    public void deleteByProcess(long processId) {
+        evaluationRepository.deleteByProcessId(processId);
     }
 }

backend/src/main/java/com/cruru/applyform/domain/repository/ApplyFormRepository.java

@@ -4,8 +4,16 @@
 import com.cruru.dashboard.domain.Dashboard;
 import java.util.Optional;
 import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
 
 public interface ApplyFormRepository extends JpaRepository<ApplyForm, Long> {
 
-    Optional<ApplyForm> findByDashboard(Dashboard dashboardId);
+    Optional<ApplyForm> findByDashboard(Dashboard dashboard);
+
+    @Query("""
+               SELECT af FROM ApplyForm af
+               JOIN FETCH af.dashboard d
+               WHERE d.id = :dashboardId
+           """)
+    Optional<ApplyForm> findByDashboardId(long dashboardId);
 }

backend/src/main/java/com/cruru/applyform/service/ApplyFormService.java

@@ -77,6 +77,11 @@ public ApplyForm findById(Long applyFormId) {
                 .orElseThrow(ApplyFormNotFoundException::new);
     }
 
+    public ApplyForm findByDashboardId(Long dashboardId) {
+        return applyFormRepository.findByDashboardId(dashboardId)
+                .orElseThrow(ApplyFormNotFoundException::new);
+    }
+
     public ApplyForm findByDashboard(Dashboard dashboard) {
         return applyFormRepository.findByDashboard(dashboard)
                 .orElseThrow(ApplyFormNotFoundException::new);

backend/src/main/java/com/cruru/email/controller/EmailController.java

@@ -1,7 +1,7 @@
 package com.cruru.email.controller;
 
-import com.cruru.email.facade.EmailFacade;
 import com.cruru.email.controller.dto.EmailRequest;
+import com.cruru.email.facade.EmailFacade;
 import jakarta.validation.Valid;
 import lombok.RequiredArgsConstructor;
 import org.springframework.http.ResponseEntity;

backend/src/main/java/com/cruru/email/domain/Email.java

@@ -3,8 +3,8 @@
 import com.cruru.BaseEntity;
 import com.cruru.applicant.domain.Applicant;
 import com.cruru.club.domain.Club;
-import com.cruru.email.exception.EmailSubjectLengthException;
 import com.cruru.email.exception.EmailContentLengthException;
+import com.cruru.email.exception.EmailSubjectLengthException;
 import jakarta.persistence.Column;
 import jakarta.persistence.Entity;
 import jakarta.persistence.FetchType;

backend/src/main/java/com/cruru/global/util/ExceptionLogger.java

@@ -9,7 +9,6 @@
 import lombok.NoArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.slf4j.MDC;
-import org.springframework.http.HttpStatus;
 import org.springframework.http.ProblemDetail;
 
 @Slf4j
@@ -35,13 +34,26 @@ private static void setMDC(HttpServletRequest request, CruruCustomException exce
         MDC.put("exceptionMessage", exception.getMessage());
     }
 
+    private static void clearMDC() {
+        MDC.clear();
+    }
+
     // MDC 초기화
     public static void info(ProblemDetail problemDetail) {
         setMDC(problemDetail);
         log.info("handle info level exception");
         clearMDC();
     }
 
+    private static void setMDC(ProblemDetail problemDetail) {
+        Map<String, Object> details = problemDetail.getProperties();
+        Map<String, String> map = new HashMap<>();
+        for (Entry<String, Object> stringObjectEntry : details.entrySet()) {
+            map.put(stringObjectEntry.getKey(), java.lang.String.valueOf(stringObjectEntry.getValue()));
+        }
+        MDC.setContextMap(map);
+    }
+
     public static void warn(ProblemDetail problemDetail) {
         setMDC(problemDetail);
         log.warn("handle warn level exception");
@@ -53,17 +65,4 @@ public static void error(ProblemDetail problemDetail) {
         log.error("handle error level exception");
         clearMDC();
     }
-
-    private static void setMDC(ProblemDetail problemDetail) {
-        Map<String, Object> details = problemDetail.getProperties();
-        Map<String, String> map = new HashMap<>();
-        for (Entry<String, Object> stringObjectEntry : details.entrySet()) {
-            map.put(stringObjectEntry.getKey(), java.lang.String.valueOf(stringObjectEntry.getValue()));
-        }
-        MDC.setContextMap(map);
-    }
-
-    private static void clearMDC() {
-        MDC.clear();
-    }
 }

backend/src/main/java/com/cruru/process/facade/ProcessFacade.java

@@ -1,7 +1,7 @@
 package com.cruru.process.facade;
 
 import com.cruru.applicant.controller.response.ApplicantCardResponse;
-import com.cruru.applicant.domain.Applicant;
+import com.cruru.applicant.domain.dto.ApplicantCard;
 import com.cruru.applicant.service.ApplicantService;
 import com.cruru.applicant.service.EvaluationService;
 import com.cruru.applyform.domain.ApplyForm;
@@ -33,28 +33,27 @@ public class ProcessFacade {
     @Transactional
     public void create(ProcessCreateRequest request, long dashboardId) {
         Dashboard dashboard = dashboardService.findById(dashboardId);
-
         processService.create(request, dashboard);
     }
 
     public ProcessResponses readAllByDashboardId(long dashboardId) {
-        Dashboard dashboard = dashboardService.findById(dashboardId);
+        ApplyForm applyForm = applyFormService.findByDashboardId(dashboardId);
+        List<Process> processes = processService.findAllByDashboard(dashboardId);
+        List<ApplicantCard> applicantCards = applicantService.findApplicantCards(processes);
+
+        List<ProcessResponse> processResponses = processes.stream()
+                .map(process -> toProcessResponse(process, applicantCards))
+                .toList();
 
-        ApplyForm applyForm = applyFormService.findByDashboard(dashboard);
-        List<Process> processes = processService.findAllByDashboard(dashboard);
-        List<ProcessResponse> processResponses = toProcessResponses(processes);
         return new ProcessResponses(applyForm.getId(), processResponses, applyForm.getTitle());
     }
 
-    private List<ProcessResponse> toProcessResponses(List<Process> processes) {
-        return processes.stream()
-                .map(this::toProcessResponse)
+    private ProcessResponse toProcessResponse(Process process, List<ApplicantCard> applicantCards) {
+        List<ApplicantCardResponse> applicantCardResponses = applicantCards.stream()
+                .filter(card -> card.processId() == process.getId())
+                .map(ApplicantCard::toResponse)
                 .toList();
-    }
 
-    private ProcessResponse toProcessResponse(Process process) {
-        List<Applicant> applicantsOfProcess = applicantService.findAllByProcess(process);
-        List<ApplicantCardResponse> applicantCardResponses = toApplicantCardResponses(process, applicantsOfProcess);
         return new ProcessResponse(
                 process.getId(),
                 process.getSequence(),
@@ -64,21 +63,6 @@ private ProcessResponse toProcessResponse(Process process) {
         );
     }
 
-    private List<ApplicantCardResponse> toApplicantCardResponses(
-            Process process,
-            List<Applicant> applicantsOfProcess
-    ) {
-        return applicantsOfProcess.stream()
-                .map(applicant -> toApplicantCardResponse(process, applicant))
-                .toList();
-    }
-
-    private ApplicantCardResponse toApplicantCardResponse(Process process, Applicant applicant) {
-        int evaluationCount = evaluationService.count(process, applicant);
-        double averageScore = evaluationService.calculateAverageScore(process, applicant);
-        return applicantService.toApplicantCardResponse(applicant, evaluationCount, averageScore);
-    }
-
     @Transactional
     public ProcessResponse update(ProcessUpdateRequest request, long processId) {
         Process process = processService.findById(processId);
@@ -87,11 +71,24 @@ public ProcessResponse update(ProcessUpdateRequest request, long processId) {
         return toProcessResponse(process);
     }
 
+    private ProcessResponse toProcessResponse(Process process) {
+        List<ApplicantCardResponse> applicantCardResponses = applicantService.findApplicantCards(process)
+                .stream()
+                .map(ApplicantCard::toResponse)
+                .toList();
+
+        return new ProcessResponse(
+                process.getId(),
+                process.getSequence(),
+                process.getName(),
+                process.getDescription(),
+                applicantCardResponses
+        );
+    }
+
     @Transactional
     public void delete(long processId) {
-        Process process = processService.findById(processId);
-
-        evaluationService.deleteByProcess(process);
+        evaluationService.deleteByProcess(processId);
         processService.delete(processId);
     }
 }

backend/src/main/java/com/cruru/process/service/ProcessService.java

@@ -64,6 +64,10 @@ private Process toEvaluateProcess(ProcessCreateRequest request, Dashboard dashbo
         return new Process(request.sequence(), request.name(), request.description(), ProcessType.EVALUATE, dashboard);
     }
 
+    public List<Process> findAllByDashboard(Long dashboardId) {
+        return processRepository.findAllByDashboardId(dashboardId);
+    }
+
     public Process findApplyProcessOnDashboard(Dashboard dashboard) {
         List<Process> processes = findAllByDashboard(dashboard);
         return processes.stream()