Release v0.16.0

src/entities/assignment/api/assignmentApi.ts

@@ -84,6 +84,22 @@ export const updateAssignment = async (
   return parsed.response;
 };
 
+// 테스트케이스 JSON 파일 업로드 API
+export const uploadTestcasesBulk = async (
+  assignmentId: number,
+  file: File
+) => {
+  const formData = new FormData();
+  formData.append('file', file);
+
+  const response = await privateAxios.post(
+    ENDPOINTS.TESTCASES.BULK(assignmentId),
+    formData
+  );
+  const parsed = apiResponseSchema(z.unknown()).parse(response.data);
+  return parsed.response;
+};
+
 // 과제 삭제 API
 export const deleteAssignment = async (assignmentId: number) => {
   const response = await privateAxios.delete(

src/entities/assignment/api/assignmentMutations.ts

@@ -4,6 +4,7 @@ import {
   updateAssignment,
   deleteAssignment,
   submitAssignment,
+  uploadTestcasesBulk,
 } from '@/entities/assignment/api/assignmentApi';
 
 interface UpdateAssignmentVariables {
@@ -28,6 +29,17 @@ export const assignmentMutations = {
       updateAssignment(assignmentId, form),
   },
 
+  uploadTestcasesBulk: {
+    mutationKey: ['uploadTestcasesBulk'],
+    mutationFn: ({
+      assignmentId,
+      file,
+    }: {
+      assignmentId: number;
+      file: File;
+    }) => uploadTestcasesBulk(assignmentId, file),
+  },
+
   submitAssignment: {
     mutationKey: ['submitAssignment'],
     mutationFn: ({

src/entities/assignment/model/schemas.ts

@@ -33,21 +33,23 @@ export const assignmentFormSchema = z.object({
   ),
 });
 
-export const assignmentDetailSchema = z.object({
-  id: z.number(),
-  title: z.string(),
-  score: z.number().optional(),
-  description: z.string(),
-  count: z.number(),
-  testcases: z.array(
-    z.object({
-      id: z.number(),
-      testcase: z.string(),
-      answer: z.string(),
-      isPublic: z.boolean(),
-    })
-  ),
-});
+export const assignmentDetailSchema = z
+  .object({
+    id: z.number(),
+    title: z.string(),
+    score: z.number().optional(),
+    description: z.string(),
+    count: z.number(),
+    testcases: z.array(
+      z.object({
+        id: z.number(),
+        testcase: z.string(),
+        answer: z.string(),
+        isPublic: z.boolean(),
+      })
+    ),
+  })
+  .passthrough();
 
 export const assignmentSubmissionResultSchema = z.object({
   codeId: z.number(),

src/entities/course/api/courseMutations.ts

@@ -1,7 +1,108 @@
-import {deleteCourse} from '@/entities/course/api/courseApi';
+import {
+  createCourse,
+  deleteCourse,
+  updateCourse,
+} from '@/entities/course/api/courseApi';
+import type {TCourseBase} from '@/entities/course/model/schemas';
+import {
+  addEnrollment,
+  getEnrollments,
+} from '@/entities/student/api/studentApi';
 
 export const courseMutations = {
-  // 강의 삭제 뮤테이션 옵션
+  // 강의 개설 (학생 등록 확인 로직 포함)
+  createCourse: {
+    mutationKey: ['createCourse'],
+    mutationFn: async (
+      payload: Parameters<typeof createCourse>[0]
+    ): Promise<{course: TCourseBase; failedIds: string[]}> => {
+      const course = await createCourse(payload);
+      const students = payload.students ?? [];
+
+      if (students.length === 0) return {course, failedIds: []};
+
+      try {
+        const enrollments = await getEnrollments(course.id, {
+          page: 0,
+          pageSize: 1000,
+        });
+        const enrolledStudentIds = new Set(
+          enrollments.response.students.map((s) => String(s.studentId))
+        );
+
+        const missingStudents = students.filter(
+          ({studentId}) => !enrolledStudentIds.has(String(studentId))
+        );
+
+        const results = await Promise.allSettled(
+          missingStudents.map(({studentId}) =>
+            addEnrollment(course.id, String(studentId))
+          )
+        );
+
+        const failedIds = results
+          .map((result, index) =>
+            result.status === 'rejected'
+              ? String(missingStudents[index].studentId)
+              : null
+          )
+          .filter((id): id is string => id !== null);
+
+        return {course, failedIds};
+      } catch {
+        // 등록 확인 실패 시에도 강의 생성 성공은 유지
+        return {course, failedIds: students.map(({studentId}) => String(studentId))};
+      }
+    },
+  },
+
+  // 강의 수정 (학생 등록 확인 로직 포함)
+  updateCourse: (courseId: number) => ({
+    mutationKey: ['updateCourse', courseId],
+    mutationFn: async (
+      data: Parameters<typeof updateCourse>[1]
+    ): Promise<{course: TCourseBase; failedIds: string[]}> => {
+      const course = await updateCourse(courseId, data);
+      const students = data.students ?? [];
+
+      if (students.length === 0) return {course, failedIds: []};
+
+      try {
+        const enrollments = await getEnrollments(courseId, {
+          page: 0,
+          pageSize: 1000,
+        });
+        const enrolledStudentIds = new Set(
+          enrollments.response.students.map((student) => String(student.studentId))
+        );
+
+        const missingStudents = students.filter(
+          ({studentId}) => !enrolledStudentIds.has(String(studentId))
+        );
+
+        const results = await Promise.allSettled(
+          missingStudents.map(({studentId}) =>
+            addEnrollment(courseId, String(studentId))
+          )
+        );
+
+        const failedIds = results
+          .map((result, index) =>
+            result.status === 'rejected'
+              ? String(missingStudents[index].studentId)
+              : null
+          )
+          .filter((id): id is string => id !== null);
+
+        return {course, failedIds};
+      } catch {
+        // 등록 확인 실패 시에도 강의 수정 성공은 유지
+        return {course, failedIds: students.map(({studentId}) => String(studentId))};
+      }
+    },
+  }),
+
+  // 강의 삭제
   deleteCourse: {
     mutationKey: ['deleteCourse'],
     mutationFn: (courseId: number) => deleteCourse(courseId),

src/entities/course/model/schemas.ts

@@ -1,6 +1,7 @@
 import {unitSchema} from '@/entities/unit/model/schemas';
 import {semesterCodeSchema} from '@/shared/model/schemas';
 import {z} from 'zod';
+import {studentSchema} from '@/entities/student/model/schemas';
 
 /** 강의 공통 핵심 필드 */
 export const courseCoreSchema = z.object({
@@ -20,7 +21,10 @@ export const courseBaseSchema = courseCoreSchema.extend({
   description: z
     .string()
     .nullish()
-    .transform((v) => v ?? ''), // 응답에서는 기본값 처리
+    .transform((v) => v ?? ''),
+  studentCount: z.number().optional(),
+  unitCount: z.number().optional(),
+  students: z.array(studentSchema).optional(),
 });
 
 /** 강의 추가/수정 요청 스키마 */
@@ -36,6 +40,7 @@ export const courseOverviewSchema = courseBaseSchema.extend({
   studentCount: z.number().optional(),
   unitCount: z.number(),
   units: z.array(unitSchema),
+  students: z.array(studentSchema).optional(),
   chatRoomId: z.number().nullable().optional(),
 });
 

src/entities/student/api/studentApi.ts

@@ -22,5 +22,24 @@ export const getEnrollmentById = async (courseId: number, memberId: number) => {
 
 export const addEnrollment = async (courseId: number, studentId: string) => {
   const res = await privateAxios.post(ENDPOINTS.ENROLLMENTS.BY_COURSE(courseId), {studentId});
-  return apiResponseSchema(z.string()).parse(res.data);
+  return apiResponseSchema(z.unknown()).parse(res.data);
+};
+
+export const addEnrollmentsBulk = async (courseId: number, file: File) => {
+  const formData = new FormData();
+  formData.append('file', file);
+
+  const res = await privateAxios.post(
+    ENDPOINTS.ENROLLMENTS.BULK(courseId),
+    formData
+  );
+
+  return apiResponseSchema(z.unknown()).parse(res.data);
+};
+
+export const deleteEnrollment = async (courseId: number, memberId: number) => {
+  const res = await privateAxios.delete(
+    ENDPOINTS.ENROLLMENTS.DETAIL(courseId, memberId)
+  );
+  return apiResponseSchema(z.unknown()).parse(res.data);
 };

src/entities/student/api/studentMutations.ts

@@ -1,8 +1,31 @@
-import {addEnrollment} from './studentApi';
+import {
+  addEnrollment,
+  addEnrollmentsBulk,
+  deleteEnrollment,
+} from './studentApi';
 
 export const studentMutations = {
   addEnrollment: (courseId: number) => ({
     mutationKey: ['addEnrollment', courseId],
     mutationFn: (studentId: string) => addEnrollment(courseId, studentId),
   }),
+
+  addEnrollmentsBulk: (courseId: number) => ({
+    mutationKey: ['addEnrollmentsBulk', courseId],
+    mutationFn: (file: File) => addEnrollmentsBulk(courseId, file),
+  }),
+  deleteEnrollmentsBulk: (courseId: number) => ({
+    mutationKey: ['deleteEnrollmentsBulk', courseId],
+    mutationFn: async (memberIds: number[]) => {
+      const results = await Promise.allSettled(
+        memberIds.map((id) => deleteEnrollment(courseId, id))
+      );
+      const failed = results
+        .map((result, index) =>
+          result.status === 'rejected' ? memberIds[index] : null
+        )
+        .filter((id): id is number => id !== null);
+      return {total: memberIds.length, failed};
+    },
+  }),
 };

src/entities/student/model/schemas.ts

@@ -32,38 +32,47 @@ export const studentUnitSchema = z.object({
 });
 
 // 목록 조회용 학생 스키마
-export const studentSchema = z.object({
-  id: z.number(),
-  studentId: z.string(),
-  name: z.string(),
-  score: z.number(),
-  totalScore: z.number(),
-  progress: z.array(studentProgressSchema),
-});
+export const studentSchema = z
+  .object({
+    id: z.number(),
+    studentId: z.union([z.string(), z.number()]).transform((v) => String(v)),
+    name: z.string(),
+    score: z.number(),
+    totalScore: z.number(),
+    progress: z.array(studentProgressSchema),
+  })
+  .passthrough();
 
 // 개별 학생 조회용 스키마
-export const studentDetailSchema = z.object({
-  id: z.number(),
-  name: z.string(),
-  studentId: z.string(),
-  email: z.string(),
-  title: z.string(),
-  score: z.number(),
-  totalScore: z.number(),
-  unitCount: z.number(),
-  progress: z.array(studentProgressSchema),
-  units: z.array(studentUnitSchema),
-});
+export const studentDetailSchema = z
+  .object({
+    id: z.number(),
+    name: z.string(),
+    studentId: z.union([z.string(), z.number()]).transform((v) => String(v)),
+    email: z.string(),
+    title: z.string(),
+    score: z.number(),
+    totalScore: z.number(),
+    unitCount: z.number(),
+    progress: z.array(studentProgressSchema),
+    units: z.array(studentUnitSchema),
+  })
+  .passthrough();
 
 // 목록 조회 response 전체 스키마
-export const enrollmentListSchema = z.object({
-  id: z.number(),
-  title: z.string(),
-  section: z.string(),
-  unitCount: z.number(),
-  studentCount: z.number(),
-  students: z.array(studentSchema),
-});
+export const enrollmentListSchema = z
+  .object({
+    id: z.number(),
+    title: z.string(),
+    section: z.string(),
+    unitCount: z.number(),
+    studentCount: z.number(),
+    students: z
+      .array(studentSchema)
+      .nullish()
+      .transform((v) => v ?? []),
+  })
+  .passthrough();
 
 export type TStudent = z.infer<typeof studentSchema>;
 export type TEnrollmentList = z.infer<typeof enrollmentListSchema>;