Feat(Course): Delete course

README.md

@@ -205,7 +205,7 @@
 - [ ] GET /courses/:courseId/modules - Get course modules
 - [ ] POST /courses - Register course
 - [ ] PUT /courses/:courseId - Update course details
-- [ ] DELETE /courses/:courseId - Delete course - make use case
+- [ ] DELETE /courses/:courseId - Delete course
 
 ### Modules
 - [ ] POST /modules - Register module

src/domain/course-management/application/repositories/courses-repository.ts

@@ -19,4 +19,5 @@ export interface CoursesRepository {
   findStudentWithCoursesByStudentId: (studentId: string) => Promise<StudentWithCoursesDTO | null>
   create: (course: Course) => Promise<Course>
   save: (course: Course) => Promise<void>
+  delete: (course: Course) => Promise<void>
 }

src/domain/course-management/application/use-cases/delete-course.spec.ts

@@ -0,0 +1,63 @@
+import { ResourceNotFoundError } from '@/core/errors/errors/resource-not-found-error'
+import { makeCourse } from '../../../../../test/factories/make-course'
+import { InMemoryClassesRepository } from '../../../../../test/repositories/in-memory-classes-repository'
+import { InMemoryCourseTagsRepository } from '../../../../../test/repositories/in-memory-course-tags-repository'
+import { InMemoryCoursesRepository } from '../../../../../test/repositories/in-memory-courses-repository'
+import { InMemoryEnrollmentsRepository } from '../../../../../test/repositories/in-memory-enrollments-repository'
+import { InMemoryInstructorRepository } from '../../../../../test/repositories/in-memory-instructors-repository'
+import { InMemoryModulesRepository } from '../../../../../test/repositories/in-memory-modules-repository'
+import { InMemoryStudentsRepository } from '../../../../../test/repositories/in-memory-students-repository'
+import { DeleteCourseUseCase } from './delete-course'
+
+let inMemoryClassesRepository: InMemoryClassesRepository
+let inMemoryCourseTagsRepository: InMemoryCourseTagsRepository
+let inMemoryEnrollmentsRepository: InMemoryEnrollmentsRepository
+let inMemoryStudentsRepository: InMemoryStudentsRepository
+let inMemoryInstructorsRepository: InMemoryInstructorRepository
+let inMemoryModulesRepository: InMemoryModulesRepository
+let inMemoryCoursesRepository: InMemoryCoursesRepository
+let sut: DeleteCourseUseCase
+
+describe('Delete course use case', () => {
+  beforeEach(() => {
+    inMemoryClassesRepository = new InMemoryClassesRepository()
+    inMemoryCourseTagsRepository = new InMemoryCourseTagsRepository()
+    inMemoryStudentsRepository = new InMemoryStudentsRepository()
+    inMemoryInstructorsRepository = new InMemoryInstructorRepository()
+
+    inMemoryModulesRepository = new InMemoryModulesRepository(inMemoryClassesRepository)
+
+    inMemoryEnrollmentsRepository = new InMemoryEnrollmentsRepository(
+      inMemoryClassesRepository, inMemoryModulesRepository, inMemoryStudentsRepository
+    )
+    inMemoryCoursesRepository = new InMemoryCoursesRepository(inMemoryModulesRepository, inMemoryInstructorsRepository, inMemoryEnrollmentsRepository, inMemoryStudentsRepository, inMemoryCourseTagsRepository)
+
+    sut = new DeleteCourseUseCase(inMemoryCoursesRepository)
+  })
+
+  it('should be able to delete a course', async () => {
+    const course = makeCourse({ name: 'John Doe Course' })
+    await inMemoryCoursesRepository.create(course)
+
+    const result = await sut.exec({
+      courseId: course.id.toString()
+    })
+
+    expect(result.isRight()).toBe(true)
+    expect(result.value).toMatchObject({
+      course: expect.objectContaining({
+        name: 'John Doe Course'
+      })
+    })
+    expect(inMemoryCourseTagsRepository.items).toHaveLength(0)
+  })
+
+  it('should not be able to delete a inexistent course', async () => {
+    const result = await sut.exec({
+      courseId: 'inexistentCourseId'
+    })
+
+    expect(result.isLeft()).toBe(true)
+    expect(result.value).toBeInstanceOf(ResourceNotFoundError)
+  })
+})

src/domain/course-management/application/use-cases/delete-course.ts

@@ -0,0 +1,38 @@
+import { left, right, type Either } from '@/core/either'
+import { ResourceNotFoundError } from '@/core/errors/errors/resource-not-found-error'
+import { type UseCase } from '@/core/use-cases/use-case'
+import { type Course } from '../../enterprise/entities/course'
+import { type CoursesRepository } from '../repositories/courses-repository'
+
+interface DeleteCourseUseCaseRequest {
+  courseId: string
+}
+
+type DeleteCourseUseCaseResponse = Either<
+ResourceNotFoundError,
+{
+  course: Course
+}
+>
+
+export class DeleteCourseUseCase implements UseCase<DeleteCourseUseCaseRequest, DeleteCourseUseCaseResponse> {
+  constructor(
+    private readonly coursesRepository: CoursesRepository
+  ) { }
+
+  async exec({
+    courseId
+  }: DeleteCourseUseCaseRequest): Promise<DeleteCourseUseCaseResponse> {
+    const course = await this.coursesRepository.findById(courseId)
+
+    if (!course) {
+      return left(new ResourceNotFoundError())
+    }
+
+    await this.coursesRepository.delete(course)
+
+    return right({
+      course
+    })
+  }
+}

test/repositories/in-memory-courses-repository.ts

@@ -239,4 +239,9 @@ export class InMemoryCoursesRepository implements CoursesRepository {
     const courseIndex = this.items.indexOf(course)
     this.items[courseIndex] = course
   }
+
+  async delete(course: Course): Promise<void> {
+    const courseIndex = this.items.indexOf(course)
+    this.items.splice(courseIndex, 1)
+  }
 }