[Add] Checklist for cards added into prisma / graphql schema

Author: EliasJHL

backend/prisma/schema.prisma

@@ -114,12 +114,22 @@ model Card {
   card_labels  CardLabel[]
   card_members CardMember[]
   attachments  Attachment[]
+  checklists Checklist[]
 
   list List @relation(fields: [list_id], references: [list_id], onDelete: Cascade)
 
   @@index([list_id])
 }
 
+model Checklist {
+  checklist_id String       @id @default(uuid())
+  content      String
+  is_completed Boolean      @default(false)
+  card_id      String
+
+  card Card @relation(fields: [card_id], references: [card_id], onDelete: Cascade)
+}
+
 model Comment {
   comment_id String   @id @default(uuid())
   content    String

backend/src/app.module.ts

@@ -27,6 +27,7 @@ import { BoardModule } from './board/board.module';
 import { ListModule } from './list/list.module';
 import { CardModule } from './card/card.module';
 import { LabelModule } from './label/label.module';
+import { ChecklistModule } from './checklist/checklist.module';
 
 @Module({
     imports: [
@@ -51,6 +52,7 @@ import { LabelModule } from './label/label.module';
         ListModule,
         CardModule,
         LabelModule,
+        ChecklistModule,
     ],
     controllers: [AppController],
     providers: [AppService],

backend/src/card/card.resolver.ts

@@ -93,4 +93,27 @@ export class CardResolver {
         });
         return members.map((m) => m.user);
     }
+
+    // @ResolveField('comments')
+    // async getComments(@Parent() card: Card) {
+    //     return this.prisma.comment.findMany({
+    //         where: { card_id: card.card_id },
+    //         orderBy: { created_at: 'asc' },
+    //     });
+    // }
+
+    // @ResolveField('attachments')
+    // async getAttachments(@Parent() card: Card) {
+    //     return this.prisma.attachment.findMany({
+    //         where: { card_id: card.card_id },
+    //         orderBy: { created_at: 'asc' },
+    //     });
+    // }
+    
+    @ResolveField('checklists')
+    async getChecklists(@Parent() card: Card) {
+        return this.prisma.checklist.findMany({
+            where: { card_id: card.card_id }
+        });
+    }
 }

backend/src/card/card.service.ts

@@ -37,8 +37,19 @@ export class CardService {
     }
 
     async delete(cardId: string) {
-        await this.prisma.card.delete({ where: { card_id: cardId } });
-        return { success: true, message: 'Card deleted' };
+        try {
+            await this.prisma.card.delete({ where: { card_id: cardId } });
+            return {
+                __typename: 'Success',
+                successMessage: 'Card deleted successfully',
+            };
+        } catch {
+            return {
+                __typename: 'Error',
+                errorMessage: 'Failed to delete card',
+                code: 'CARD_DELETE_FAILED',
+            };
+        }
     }
 
     async move(cardId: string, listId: string, position: number) {

backend/src/checklist/checklist.module.ts

@@ -0,0 +1,8 @@
+import { Module } from '@nestjs/common';
+import { ChecklistService } from './checklist.service';
+import { ChecklistResolver } from './checklist.resolver';
+
+@Module({
+  providers: [ChecklistService, ChecklistResolver]
+})
+export class ChecklistModule {}

backend/src/checklist/checklist.resolver.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { ChecklistResolver } from './checklist.resolver';
+
+describe('ChecklistResolver', () => {
+  let resolver: ChecklistResolver;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [ChecklistResolver],
+    }).compile();
+
+    resolver = module.get<ChecklistResolver>(ChecklistResolver);
+  });
+
+  it('should be defined', () => {
+    expect(resolver).toBeDefined();
+  });
+});

backend/src/checklist/checklist.resolver.ts

@@ -0,0 +1,41 @@
+/*
+** EPITECH PROJECT, 2025
+** TaskFlow
+** File description:
+** checklist.resolver
+*/
+
+import {
+    Resolver,
+    Mutation,
+    Args,
+    ResolveField,
+    Parent,
+} from '@nestjs/graphql';
+import { ChecklistService } from './checklist.service';
+import { PrismaService } from '../prisma/prisma.service';
+import { CreateChecklistInput } from '../graphql/graphql';
+import { UseGuards } from '@nestjs/common';
+import { AuthGuard } from '../common/guards/auth.guard';
+
+@Resolver()
+export class ChecklistResolver {
+    constructor(
+        private checklistService: ChecklistService,
+        private prisma: PrismaService,
+    ) {}
+
+    @Mutation('createChecklist')
+    @UseGuards(AuthGuard)
+    async createChecklist(
+        @Args('input') input: CreateChecklistInput,
+    ) {
+        return this.checklistService.create(input);
+    }
+
+    @Mutation('deleteChecklist')
+    @UseGuards(AuthGuard)
+    async deleteChecklist(@Args('checklist_id') checklistId: string) {
+        return this.checklistService.delete(checklistId);
+    }
+}

backend/src/checklist/checklist.service.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { ChecklistService } from './checklist.service';
+
+describe('ChecklistService', () => {
+  let service: ChecklistService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [ChecklistService],
+    }).compile();
+
+    service = module.get<ChecklistService>(ChecklistService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

backend/src/checklist/checklist.service.ts

@@ -0,0 +1,31 @@
+/*
+** EPITECH PROJECT, 2025
+** TaskFlow
+** File description:
+** checklist.service
+*/
+
+import { Injectable } from '@nestjs/common';
+import { PrismaService } from '../prisma/prisma.service';
+import { CreateChecklistInput } from '../graphql/graphql';
+
+@Injectable()
+export class ChecklistService {
+    constructor(private prisma: PrismaService) {}
+
+    async create(input: CreateChecklistInput) {
+        return this.prisma.checklist.create({
+            data: {
+                card_id: input.card_id,
+                content: input.content,
+            },
+        });
+    }
+
+    async delete(checklistId: string) {
+        await this.prisma.checklist.delete({
+            where: { checklist_id: checklistId },
+        });
+        return { success: true, message: 'Checklist deleted' };
+    }
+}

backend/src/graphql/graphql.ts

@@ -58,6 +58,11 @@ export class UpdateCardInput {
     due_date?: Nullable<DateTime>;
 }
 
+export class CreateChecklistInput {
+    content: string;
+    card_id: string;
+}
+
 export class LoginInput {
     email: string;
     password: string;
@@ -138,6 +143,14 @@ export class Card {
     comments: Comment[];
     attachments: Attachment[];
     assignees: User[];
+    checklists: Checklist[];
+}
+
+export class Checklist {
+    checklist_id: string;
+    content: string;
+    is_completed: boolean;
+    card_id: string;
 }
 
 export class Comment {
@@ -206,6 +219,10 @@ export abstract class IMutation {
 
     abstract moveCard(card_id: string, list_id: string, new_position: number): Card | Promise<Card>;
 
+    abstract createChecklist(input: CreateChecklistInput): Checklist | Promise<Checklist>;
+
+    abstract deleteChecklist(checklist_id: string): Status | Promise<Status>;
+
     abstract addLabelToCard(card_id: string, label_id: string): Card | Promise<Card>;
 
     abstract removeLabelFromCard(card_id: string, label_id: string): Card | Promise<Card>;