refactor: System 1 모델/컨트롤러 콜백→async/await 전환

11개 모델 파일의 171개 콜백 메서드를 직접 return/throw 패턴으로 변환.
8개 컨트롤러에서 new Promise 래퍼와 중첩 콜백 제거, console.error→logger.error 교체.
미사용 pageAccessModel.js 삭제. 전체 -3,600줄 감소.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

system1-factory/api/tests/unit/services/workReportService.test.js

@@ -19,7 +19,6 @@ describe('WorkReportService', () => {
 
   describe('createWorkReportService', () => {
     it('단일 보고서를 성공적으로 생성해야 함', async () => {
-      // Arrange
       const reportData = {
         report_date: '2025-12-11',
         worker_id: 1,
@@ -29,46 +28,32 @@ describe('WorkReportService', () => {
         work_content: '기능 개발'
       };
 
-      // workReportModel.create가 콜백 형태이므로 모킹 설정
-      workReportModel.create = jest.fn((data, callback) => {
-        callback(null, 123); // insertId = 123
-      });
+      workReportModel.create.mockResolvedValue(123);
 
-      // Act
       const result = await workReportService.createWorkReportService(reportData);
 
-      // Assert
       expect(result).toEqual({ workReport_ids: [123] });
       expect(workReportModel.create).toHaveBeenCalledTimes(1);
-      expect(workReportModel.create).toHaveBeenCalledWith(
-        reportData,
-        expect.any(Function)
-      );
+      expect(workReportModel.create).toHaveBeenCalledWith(reportData);
     });
 
     it('다중 보고서를 성공적으로 생성해야 함', async () => {
-      // Arrange
       const reportsData = [
         { report_date: '2025-12-11', worker_id: 1, work_hours: 8 },
         { report_date: '2025-12-11', worker_id: 2, work_hours: 7 }
       ];
 
-      let callCount = 0;
-      workReportModel.create = jest.fn((data, callback) => {
-        callCount++;
-        callback(null, 100 + callCount);
-      });
+      workReportModel.create
+        .mockResolvedValueOnce(101)
+        .mockResolvedValueOnce(102);
 
-      // Act
       const result = await workReportService.createWorkReportService(reportsData);
 
-      // Assert
       expect(result).toEqual({ workReport_ids: [101, 102] });
       expect(workReportModel.create).toHaveBeenCalledTimes(2);
     });
 
     it('빈 배열이면 ValidationError를 던져야 함', async () => {
-      // Act & Assert
       await expect(workReportService.createWorkReportService([]))
         .rejects.toThrow(ValidationError);
 
@@ -77,14 +62,10 @@ describe('WorkReportService', () => {
     });
 
     it('DB 오류 시 DatabaseError를 던져야 함', async () => {
-      // Arrange
       const reportData = { report_date: '2025-12-11', worker_id: 1 };
 
-      workReportModel.create = jest.fn((data, callback) => {
-        callback(new Error('DB connection failed'), null);
-      });
+      workReportModel.create.mockRejectedValue(new Error('DB connection failed'));
 
-      // Act & Assert
       await expect(workReportService.createWorkReportService(reportData))
         .rejects.toThrow(DatabaseError);
     });
@@ -92,24 +73,18 @@ describe('WorkReportService', () => {
 
   describe('getWorkReportsByDateService', () => {
     it('날짜로 보고서를 조회해야 함', async () => {
-      // Arrange
       const date = '2025-12-11';
       const mockReports = mockWorkReports.filter(r => r.report_date === date);
 
-      workReportModel.getAllByDate = jest.fn((date, callback) => {
-        callback(null, mockReports);
-      });
+      workReportModel.getAllByDate.mockResolvedValue(mockReports);
 
-      // Act
       const result = await workReportService.getWorkReportsByDateService(date);
 
-      // Assert
       expect(result).toEqual(mockReports);
-      expect(workReportModel.getAllByDate).toHaveBeenCalledWith(date, expect.any(Function));
+      expect(workReportModel.getAllByDate).toHaveBeenCalledWith(date);
     });
 
     it('날짜가 없으면 ValidationError를 던져야 함', async () => {
-      // Act & Assert
       await expect(workReportService.getWorkReportsByDateService(null))
         .rejects.toThrow(ValidationError);
 
@@ -118,12 +93,8 @@ describe('WorkReportService', () => {
     });
 
     it('DB 오류 시 DatabaseError를 던져야 함', async () => {
-      // Arrange
-      workReportModel.getAllByDate = jest.fn((date, callback) => {
-        callback(new Error('DB error'), null);
-      });
+      workReportModel.getAllByDate.mockRejectedValue(new Error('DB error'));
 
-      // Act & Assert
       await expect(workReportService.getWorkReportsByDateService('2025-12-11'))
         .rejects.toThrow(DatabaseError);
     });
@@ -131,28 +102,19 @@ describe('WorkReportService', () => {
 
   describe('getWorkReportByIdService', () => {
     it('ID로 보고서를 조회해야 함', async () => {
-      // Arrange
       const mockReport = mockWorkReports[0];
 
-      workReportModel.getById = jest.fn((id, callback) => {
-        callback(null, mockReport);
-      });
+      workReportModel.getById.mockResolvedValue(mockReport);
 
-      // Act
       const result = await workReportService.getWorkReportByIdService(1);
 
-      // Assert
       expect(result).toEqual(mockReport);
-      expect(workReportModel.getById).toHaveBeenCalledWith(1, expect.any(Function));
+      expect(workReportModel.getById).toHaveBeenCalledWith(1);
     });
 
     it('보고서가 없으면 NotFoundError를 던져야 함', async () => {
-      // Arrange
-      workReportModel.getById = jest.fn((id, callback) => {
-        callback(null, null);
-      });
+      workReportModel.getById.mockResolvedValue(null);
 
-      // Act & Assert
       await expect(workReportService.getWorkReportByIdService(999))
         .rejects.toThrow(NotFoundError);
 
@@ -161,7 +123,6 @@ describe('WorkReportService', () => {
     });
 
     it('ID가 없으면 ValidationError를 던져야 함', async () => {
-      // Act & Assert
       await expect(workReportService.getWorkReportByIdService(null))
         .rejects.toThrow(ValidationError);
     });
@@ -169,38 +130,24 @@ describe('WorkReportService', () => {
 
   describe('updateWorkReportService', () => {
     it('보고서를 성공적으로 수정해야 함', async () => {
-      // Arrange
       const updateData = { work_hours: 9 };
 
-      workReportModel.update = jest.fn((id, data, callback) => {
-        callback(null, 1); // affectedRows = 1
-      });
+      workReportModel.update.mockResolvedValue(1);
 
-      // Act
       const result = await workReportService.updateWorkReportService(123, updateData);
 
-      // Assert
       expect(result).toEqual({ changes: 1 });
-      expect(workReportModel.update).toHaveBeenCalledWith(
-        123,
-        updateData,
-        expect.any(Function)
-      );
+      expect(workReportModel.update).toHaveBeenCalledWith(123, updateData);
     });
 
     it('수정할 보고서가 없으면 NotFoundError를 던져야 함', async () => {
-      // Arrange
-      workReportModel.update = jest.fn((id, data, callback) => {
-        callback(null, 0); // affectedRows = 0
-      });
+      workReportModel.update.mockResolvedValue(0);
 
-      // Act & Assert
       await expect(workReportService.updateWorkReportService(999, {}))
         .rejects.toThrow(NotFoundError);
     });
 
     it('ID가 없으면 ValidationError를 던져야 함', async () => {
-      // Act & Assert
       await expect(workReportService.updateWorkReportService(null, {}))
         .rejects.toThrow(ValidationError);
     });
@@ -208,32 +155,22 @@ describe('WorkReportService', () => {
 
   describe('removeWorkReportService', () => {
     it('보고서를 성공적으로 삭제해야 함', async () => {
-      // Arrange
-      workReportModel.remove = jest.fn((id, callback) => {
-        callback(null, 1);
-      });
+      workReportModel.remove.mockResolvedValue(1);
 
-      // Act
       const result = await workReportService.removeWorkReportService(123);
 
-      // Assert
       expect(result).toEqual({ changes: 1 });
-      expect(workReportModel.remove).toHaveBeenCalledWith(123, expect.any(Function));
+      expect(workReportModel.remove).toHaveBeenCalledWith(123);
     });
 
     it('삭제할 보고서가 없으면 NotFoundError를 던져야 함', async () => {
-      // Arrange
-      workReportModel.remove = jest.fn((id, callback) => {
-        callback(null, 0);
-      });
+      workReportModel.remove.mockResolvedValue(0);
 
-      // Act & Assert
       await expect(workReportService.removeWorkReportService(999))
         .rejects.toThrow(NotFoundError);
     });
 
     it('ID가 없으면 ValidationError를 던져야 함', async () => {
-      // Act & Assert
       await expect(workReportService.removeWorkReportService(null))
         .rejects.toThrow(ValidationError);
     });
@@ -241,34 +178,23 @@ describe('WorkReportService', () => {
 
   describe('getWorkReportsInRangeService', () => {
     it('기간으로 보고서를 조회해야 함', async () => {
-      // Arrange
       const start = '2025-12-01';
       const end = '2025-12-31';
 
-      workReportModel.getByRange = jest.fn((start, end, callback) => {
-        callback(null, mockWorkReports);
-      });
+      workReportModel.getByRange.mockResolvedValue(mockWorkReports);
 
-      // Act
       const result = await workReportService.getWorkReportsInRangeService(start, end);
 
-      // Assert
       expect(result).toEqual(mockWorkReports);
-      expect(workReportModel.getByRange).toHaveBeenCalledWith(
-        start,
-        end,
-        expect.any(Function)
-      );
+      expect(workReportModel.getByRange).toHaveBeenCalledWith(start, end);
     });
 
     it('시작일이 없으면 ValidationError를 던져야 함', async () => {
-      // Act & Assert
       await expect(workReportService.getWorkReportsInRangeService(null, '2025-12-31'))
         .rejects.toThrow(ValidationError);
     });
 
     it('종료일이 없으면 ValidationError를 던져야 함', async () => {
-      // Act & Assert
       await expect(workReportService.getWorkReportsInRangeService('2025-12-01', null))
         .rejects.toThrow(ValidationError);
     });
@@ -276,41 +202,30 @@ describe('WorkReportService', () => {
 
   describe('getSummaryService', () => {
     it('월간 요약을 조회해야 함', async () => {
-      // Arrange
       const year = '2025';
       const month = '12';
 
-      workReportModel.getByRange = jest.fn((start, end, callback) => {
-        callback(null, mockWorkReports);
-      });
+      workReportModel.getByRange.mockResolvedValue(mockWorkReports);
 
-      // Act
       const result = await workReportService.getSummaryService(year, month);
 
-      // Assert
       expect(result).toEqual(mockWorkReports);
       expect(workReportModel.getByRange).toHaveBeenCalled();
     });
 
     it('연도가 없으면 ValidationError를 던져야 함', async () => {
-      // Act & Assert
       await expect(workReportService.getSummaryService(null, '12'))
         .rejects.toThrow(ValidationError);
     });
 
     it('월이 없으면 ValidationError를 던져야 함', async () => {
-      // Act & Assert
       await expect(workReportService.getSummaryService('2025', null))
         .rejects.toThrow(ValidationError);
     });
 
     it('데이터가 없으면 NotFoundError를 던져야 함', async () => {
-      // Arrange
-      workReportModel.getByRange = jest.fn((start, end, callback) => {
-        callback(null, []);
-      });
+      workReportModel.getByRange.mockResolvedValue([]);
 
-      // Act & Assert
       await expect(workReportService.getSummaryService('2025', '12'))
         .rejects.toThrow(NotFoundError);