fix/student sync

.gitignore

@@ -18,6 +18,7 @@ dist
 # misc
 .vscode
 .cursor
+.omx 
 .DS_Store
 .env.local
 .env.development.local

src/config/container.config.ts

@@ -204,6 +204,8 @@ const lecturesService = new LecturesService(
   enrollmentsRepo,
   lectureEnrollmentsRepo,
   instructorRepo,
+  studentRepo,
+  parentChildLinkRepo,
   permissionService,
   prisma,
 );

src/repos/enrollments.repo.ts

@@ -374,16 +374,20 @@ export class EnrollmentsRepository {
     });
   }
 
-  /** 학생 전화번호 기준 AppParentLinkId 업데이트 (자녀 등록 시 연동) */
+  /** 학생/학부모 프로필 기준 AppParentLinkId 업데이트 (자녀 등록 시 연동) */
   async updateAppParentLinkIdByStudentPhone(
     studentPhone: string,
+    studentName: string,
+    parentPhoneNumber: string,
     appParentLinkId: string,
     tx?: Prisma.TransactionClient,
   ) {
     const client = tx ?? this.prisma;
     return await client.enrollment.updateMany({
       where: {
-        studentPhone: studentPhone,
+        studentPhone,
+        studentName,
+        parentPhone: parentPhoneNumber,
         appParentLinkId: null, // 아직 연동되지 않은 건들이만
       },
       data: {

src/services/enrollments.service.test.ts

@@ -306,6 +306,161 @@ describe('EnrollmentsService - @unit #critical', () => {
         );
       });
 
+      it('기존 Enrollment를 재사용할 때 appStudentId가 비어 있으면 자동 연결을 보정한다', async () => {
+        const existingEnrollment = {
+          ...mockEnrollments.active,
+          appStudentId: null,
+          studentPhone: createEnrollmentRequests.basic.studentPhone,
+          studentName: createEnrollmentRequests.basic.studentName,
+          parentPhone: createEnrollmentRequests.basic.parentPhone,
+        };
+
+        mockLecturesRepo.findById.mockResolvedValue(mockLectures.basic);
+        mockPermissionService.validateInstructorAccess.mockResolvedValue();
+        mockEnrollmentsRepo.findManyByInstructorAndPhones.mockResolvedValue([
+          existingEnrollment,
+        ]);
+        mockStudentRepo.findByPhoneNumberAndProfile.mockResolvedValue(
+          mockStudents.basic,
+        );
+        mockEnrollmentsRepo.update.mockResolvedValue({
+          ...existingEnrollment,
+          appStudentId: mockStudents.basic.id,
+        });
+        mockLectureEnrollmentsRepo.findByLectureIdAndEnrollmentId.mockResolvedValueOnce(
+          null,
+        );
+        mockLectureEnrollmentsRepo.create.mockResolvedValue({
+          id: 'le-1',
+          memo: null,
+          lectureId,
+          enrollmentId: existingEnrollment.id,
+          registeredAt: new Date(),
+        });
+        mockLectureEnrollmentsRepo.findByLectureIdAndEnrollmentId.mockResolvedValueOnce(
+          {
+            id: 'le-1',
+            memo: null,
+            lectureId,
+            enrollmentId: existingEnrollment.id,
+            registeredAt: new Date(),
+            enrollment: {
+              ...existingEnrollment,
+              appStudentId: mockStudents.basic.id,
+            },
+          },
+        );
+
+        await enrollmentsService.createEnrollment(
+          lectureId,
+          {
+            ...createEnrollmentRequests.basic,
+            instructorId,
+            status: EnrollmentStatus.ACTIVE,
+          },
+          UserType.INSTRUCTOR,
+          instructorId,
+        );
+
+        expect(
+          mockStudentRepo.findByPhoneNumberAndProfile,
+        ).toHaveBeenCalledWith(
+          createEnrollmentRequests.basic.studentPhone,
+          createEnrollmentRequests.basic.studentName,
+          createEnrollmentRequests.basic.parentPhone,
+          mockPrisma,
+        );
+        expect(mockEnrollmentsRepo.update).toHaveBeenCalledWith(
+          existingEnrollment.id,
+          {
+            appStudent: {
+              connect: {
+                id: mockStudents.basic.id,
+              },
+            },
+          },
+          mockPrisma,
+        );
+        expect(mockEnrollmentsRepo.create).not.toHaveBeenCalled();
+      });
+
+      it('기존 Enrollment를 재사용할 때 appParentLinkId가 비어 있으면 자동 연결을 보정한다', async () => {
+        const existingEnrollment = {
+          ...mockEnrollments.active,
+          appParentLinkId: null,
+          studentPhone: createEnrollmentRequests.basic.studentPhone,
+          studentName: createEnrollmentRequests.basic.studentName,
+          parentPhone: createEnrollmentRequests.basic.parentPhone,
+        };
+
+        mockLecturesRepo.findById.mockResolvedValue(mockLectures.basic);
+        mockPermissionService.validateInstructorAccess.mockResolvedValue();
+        mockEnrollmentsRepo.findManyByInstructorAndPhones.mockResolvedValue([
+          existingEnrollment,
+        ]);
+        mockParentsService.findLinkByPhoneNumberAndProfile.mockResolvedValue(
+          mockParentLinks.active,
+        );
+        mockEnrollmentsRepo.update.mockResolvedValue({
+          ...existingEnrollment,
+          appParentLinkId: mockParentLinks.active.id,
+        });
+        mockLectureEnrollmentsRepo.findByLectureIdAndEnrollmentId.mockResolvedValueOnce(
+          null,
+        );
+        mockLectureEnrollmentsRepo.create.mockResolvedValue({
+          id: 'le-1',
+          memo: null,
+          lectureId,
+          enrollmentId: existingEnrollment.id,
+          registeredAt: new Date(),
+        });
+        mockLectureEnrollmentsRepo.findByLectureIdAndEnrollmentId.mockResolvedValueOnce(
+          {
+            id: 'le-1',
+            memo: null,
+            lectureId,
+            enrollmentId: existingEnrollment.id,
+            registeredAt: new Date(),
+            enrollment: {
+              ...existingEnrollment,
+              appParentLinkId: mockParentLinks.active.id,
+            },
+          },
+        );
+
+        await enrollmentsService.createEnrollment(
+          lectureId,
+          {
+            ...createEnrollmentRequests.basic,
+            instructorId,
+            status: EnrollmentStatus.ACTIVE,
+          },
+          UserType.INSTRUCTOR,
+          instructorId,
+        );
+
+        expect(
+          mockParentsService.findLinkByPhoneNumberAndProfile,
+        ).toHaveBeenCalledWith(
+          createEnrollmentRequests.basic.studentPhone,
+          createEnrollmentRequests.basic.studentName,
+          createEnrollmentRequests.basic.parentPhone,
+        );
+        expect(mockEnrollmentsRepo.update).toHaveBeenCalledWith(
+          existingEnrollment.id,
+          {
+            appParentLink: {
+              connect: {
+                id: mockParentLinks.active.id,
+              },
+            },
+          },
+          mockPrisma,
+        );
+        expect(mockEnrollmentsRepo.create).not.toHaveBeenCalled();
+      });
+
       it('수강생 등록 시 학생 전화번호가 학부모-자녀 링크와 일치할 때, ParentLink가 자동으로 연결된다', async () => {
         mockLecturesRepo.findById.mockResolvedValue(mockLectures.basic);
         mockPermissionService.validateInstructorAccess.mockResolvedValue();

src/services/enrollments.service.ts

@@ -84,29 +84,38 @@ export class EnrollmentsService {
     );
 
     return await this.prisma.$transaction(async (tx) => {
-      // 3. 기존 Enrollment 확인 (같은 강사, 같은 학생 번호)
-      let enrollmentId: string | null = null;
+      const resolveStudentId = async () => {
+        let studentId = data.appStudentId;
 
-      if (data.studentPhone) {
-        const existingEnrollments =
-          await this.enrollmentsRepository.findManyByInstructorAndPhones(
-            lecture.instructorId,
-            [data.studentPhone],
-            tx,
-          );
+        if (!studentId && data.studentPhone) {
+          const studentPhone = data.studentPhone as string;
+          const studentName = data.studentName as string | undefined;
+          const parentPhone = data.parentPhone as string | undefined;
 
-        if (existingEnrollments.length > 0) {
-          enrollmentId = existingEnrollments[0].id;
+          if (studentName && parentPhone) {
+            const student =
+              await this.studentRepository.findByPhoneNumberAndProfile(
+                studentPhone,
+                studentName,
+                parentPhone,
+                tx,
+              );
+            if (student) {
+              studentId = student.id;
+            }
+          }
         }
-      }
 
-      // 4. 없으면 새로 생성
-      if (!enrollmentId) {
+        return studentId;
+      };
+
+      const resolveParentLinkId = async () => {
         let parentLinkId = data.appParentLinkId;
+
         if (!parentLinkId && data.studentPhone) {
           const studentPhone = data.studentPhone as string;
-          const studentName = data.studentName as string | undefined;
-          const parentPhone = data.parentPhone as string | undefined;
+          const studentName = data.studentName as string;
+          const parentPhone = data.parentPhone as string;
 
           if (studentName && parentPhone) {
             const link =
@@ -121,25 +130,55 @@ export class EnrollmentsService {
           }
         }
 
-        let studentId = data.appStudentId;
-        if (!studentId && data.studentPhone) {
-          const studentPhone = data.studentPhone as string;
-          const studentName = data.studentName as string | undefined;
-          const parentPhone = data.parentPhone as string | undefined;
+        return parentLinkId;
+      };
 
-          if (studentName && parentPhone) {
-            const student =
-              await this.studentRepository.findByPhoneNumberAndProfile(
-                studentPhone,
-                studentName,
-                parentPhone,
-                tx,
-              );
-            if (student) {
-              studentId = student.id;
+      // 3. 기존 Enrollment 확인 (같은 강사, 같은 학생 번호)
+      let enrollmentId: string | null = null;
+
+      if (data.studentPhone) {
+        const existingEnrollments =
+          await this.enrollmentsRepository.findManyByInstructorAndPhones(
+            lecture.instructorId,
+            [data.studentPhone],
+            tx,
+          );
+
+        if (existingEnrollments.length > 0) {
+          const existingEnrollment = existingEnrollments[0];
+          enrollmentId = existingEnrollment.id;
+          const connectionData: Prisma.EnrollmentUpdateInput = {};
+
+          if (!existingEnrollment.appStudentId) {
+            const studentId = await resolveStudentId();
+            if (studentId) {
+              connectionData.appStudent = { connect: { id: studentId } };
             }
           }
+
+          if (!existingEnrollment.appParentLinkId) {
+            const parentLinkId = await resolveParentLinkId();
+            if (parentLinkId) {
+              connectionData.appParentLink = {
+                connect: { id: parentLinkId },
+              };
+            }
+          }
+
+          if (Object.keys(connectionData).length > 0) {
+            await this.enrollmentsRepository.update(
+              existingEnrollment.id,
+              connectionData,
+              tx,
+            );
+          }
         }
+      }
+
+      // 4. 없으면 새로 생성
+      if (!enrollmentId) {
+        const parentLinkId = await resolveParentLinkId();
+        const studentId = await resolveStudentId();
 
         const newEnrollment = await this.enrollmentsRepository.create(
           {