48 create addedit task

.github/CODEOWNERS

@@ -0,0 +1 @@
+*    @maxn990 @amywng

apps/backend/src/app.module.ts

@@ -3,11 +3,16 @@ import { TypeOrmModule } from '@nestjs/typeorm';
 
 import { AppController } from './app.controller';
 import { AppService } from './app.service';
-import { TaskModule } from './task/task.module';
 import AppDataSource from './data-source';
+import { TaskModule } from './task/task.module';
+import { LabelModule } from './label/label.module';
 
 @Module({
-  imports: [TypeOrmModule.forRoot(AppDataSource.options), TaskModule],
+  imports: [
+    TypeOrmModule.forRoot(AppDataSource.options),
+    TaskModule,
+    LabelModule,
+  ],
   controllers: [AppController],
   providers: [AppService],
 })

apps/backend/src/data-source.ts

@@ -1,6 +1,7 @@
 import { DataSource } from 'typeorm';
 import { PluralNamingStrategy } from './strategies/plural-naming.strategy';
 import { Task } from './task/types/task.entity';
+import { Label } from './label/types/label.entity';
 import * as dotenv from 'dotenv';
 
 dotenv.config();
@@ -12,7 +13,7 @@ const AppDataSource = new DataSource({
   username: process.env.NX_DB_USERNAME,
   password: process.env.NX_DB_PASSWORD,
   database: process.env.NX_DB_DATABASE,
-  entities: [Task],
+  entities: [Task, Label],
   migrations: ['apps/backend/src/migrations/*.js'],
   // Setting synchronize: true shouldn't be used in production - otherwise you can lose production data
   synchronize: false,

apps/backend/src/label/dtos/create-label.dto.ts

@@ -0,0 +1,9 @@
+import { IsString, IsHexColor } from 'class-validator';
+
+export class CreateLabelDTO {
+  @IsString()
+  name: string;
+
+  @IsHexColor()
+  color: string;
+}

apps/backend/src/label/label.controller.spec.ts

@@ -0,0 +1,90 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { LabelsController } from './label.controller';
+import { LabelsService } from './label.service';
+import { CreateLabelDTO } from './dtos/create-label.dto';
+import { Label } from './types/label.entity';
+
+// Mock implementation for LabelsService
+export const mockLabelService: Partial<LabelsService> = {
+  createLabel: jest.fn((labelDto: CreateLabelDTO) =>
+    Promise.resolve(mockLabel),
+  ),
+  getAllLabels: jest.fn(() => Promise.resolve([mockLabel])),
+};
+
+export const mockLabelDto: CreateLabelDTO = {
+  name: 'Test Label',
+  color: '#000000',
+};
+
+export const mockLabel: Label = {
+  id: 1,
+  name: 'Test Label',
+  color: '#000000',
+  tasks: [],
+};
+
+export const mockLabel2: Label = {
+  id: 2,
+  name: 'Test Label 2',
+  color: '#802b2bff',
+  tasks: [],
+};
+
+describe('LabelController', () => {
+  let controller: LabelsController;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [LabelsController],
+      providers: [
+        {
+          provide: LabelsService,
+          useValue: mockLabelService,
+        },
+      ],
+    }).compile();
+
+    controller = module.get<LabelsController>(LabelsController);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+
+  /* Test for create new label */
+  describe('POST /labels', () => {
+    it('should create a new label and return it', async () => {
+      jest.spyOn(mockLabelService, 'createLabel').mockResolvedValue(mockLabel);
+
+      const res = await controller.createLabel(mockLabelDto);
+
+      expect(res).toEqual(mockLabel);
+      expect(mockLabelService.createLabel).toHaveBeenCalledWith(mockLabelDto);
+    });
+  });
+
+  /* Test for retrieve all labels */
+  describe('GET /labels', () => {
+    it('should return an array of labels', async () => {
+      jest
+        .spyOn(mockLabelService, 'getAllLabels')
+        .mockResolvedValue([mockLabel]);
+
+      const res = await controller.getAllLabels();
+
+      expect(res).toEqual([mockLabel]);
+      expect(mockLabelService.getAllLabels).toHaveBeenCalled();
+    });
+    it('should return an array of labels with 2 labels', async () => {
+      jest
+        .spyOn(mockLabelService, 'getAllLabels')
+        .mockResolvedValue([mockLabel, mockLabel2]);
+
+      const res = await controller.getAllLabels();
+
+      expect(res).toEqual([mockLabel, mockLabel2]);
+      expect(mockLabelService.getAllLabels).toHaveBeenCalled();
+    });
+  });
+});

apps/backend/src/label/label.controller.ts

@@ -0,0 +1,40 @@
+import {
+  Controller,
+  Get,
+  Post,
+  Body,
+  Patch,
+  Param,
+  Delete,
+  Query,
+} from '@nestjs/common';
+import { ApiTags, ApiOperation, ApiResponse } from '@nestjs/swagger';
+import { LabelsService } from './label.service';
+import { Label } from './types/label.entity';
+import { CreateLabelDTO } from './dtos/create-label.dto';
+
+@ApiTags('labels')
+@Controller('labels')
+export class LabelsController {
+  constructor(private readonly labelsService: LabelsService) {}
+
+  /** Creates a new label.
+   * @param LabelDto - The data transfer object containing label details.
+   * @returns The created label.
+   * @throws BadRequestException if the label name is not unique
+   * @throws BadRequestException if label name is not provided
+   * @throws BadRequestException if color is not provided or is not hexadecimal
+   */
+  @Post('/label')
+  async createLabel(@Body() labelDto: CreateLabelDTO): Promise<Label> {
+    return this.labelsService.createLabel(labelDto);
+  }
+
+  /** Gets all labels.
+   * @returns An array of all labels.
+   */
+  @Get()
+  async getAllLabels(): Promise<Label[]> {
+    return this.labelsService.getAllLabels();
+  }
+}

apps/backend/src/label/label.module.ts

@@ -0,0 +1,13 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { Label } from './types/label.entity';
+import { LabelsService } from './label.service';
+import { LabelsController } from './label.controller';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([Label])],
+  providers: [LabelsService],
+  controllers: [LabelsController],
+  exports: [LabelsService],
+})
+export class LabelModule {}

apps/backend/src/label/label.service.spec.ts

@@ -0,0 +1,104 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { mock } from 'jest-mock-extended';
+import { getRepositoryToken } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { Label } from './types/label.entity';
+import { LabelsService } from './label.service';
+import { mockLabel, mockLabelDto } from './label.controller.spec';
+import { BadRequestException } from '@nestjs/common';
+
+const mockLabelsRepository = mock<Repository<Label>>();
+
+describe('LabelService', () => {
+  let service: LabelsService;
+
+  const mockValidCreateLabelDTO = {
+    name: 'Label 1',
+    color: '#000000',
+  };
+
+  const mockInvalidCreateLabelDTO1 = {
+    name: '',
+    color: '#000000',
+  };
+
+  const mockInvalidCreateLabelDTO2 = {
+    name: 'Label 2',
+    color: '',
+  };
+
+  const mockInvalidCreateLabelDTO3 = {
+    name: 'Label 3',
+    color: 'Hello',
+  };
+
+  beforeEach(async () => {
+    mockLabelsRepository.create.mockReset();
+    mockLabelsRepository.save.mockReset();
+    mockLabelsRepository.findOneBy.mockReset();
+    mockLabelsRepository.find.mockReset();
+
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        LabelsService,
+        {
+          provide: getRepositoryToken(Label),
+          useValue: mockLabelsRepository,
+        },
+      ],
+    }).compile();
+
+    service = module.get<LabelsService>(LabelsService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+
+  describe('createLabel', () => {
+    it('should create a new label and return it', async () => {
+      // Mock the repository methods
+      mockLabelsRepository.create.mockReturnValue(mockLabel);
+      mockLabelsRepository.save.mockResolvedValue(mockLabel);
+
+      const label = await service.createLabel(mockValidCreateLabelDTO);
+
+      expect(label).toEqual(mockLabel);
+    });
+
+    it('should throw a BadRequestException when given null label name', async () => {
+      expect(async () => {
+        await service.createLabel(mockInvalidCreateLabelDTO1);
+      }).rejects.toThrow(
+        new BadRequestException("The 'name' field cannot be null"),
+      );
+    });
+
+    it('should throw a BadRequestException when given null label color', async () => {
+      expect(async () => {
+        await service.createLabel(mockInvalidCreateLabelDTO2);
+      }).rejects.toThrow(
+        new BadRequestException("The 'color' field cannot be null"),
+      );
+    });
+
+    it('should throw a BadRequestException when given invalid label color', async () => {
+      expect(async () => {
+        await service.createLabel(mockInvalidCreateLabelDTO3);
+      }).rejects.toThrow(
+        new BadRequestException("The 'color' field must be a valid hex color"),
+      );
+    });
+  });
+
+  describe('getAllLabels', () => {
+    it('should return an array of labels', async () => {
+      mockLabelsRepository.find.mockResolvedValue([mockLabel]);
+
+      const result = await service.getAllLabels();
+
+      expect(result).toEqual([mockLabel]);
+      expect(mockLabelsRepository.find).toHaveBeenCalled();
+    });
+  });
+});

apps/backend/src/label/label.service.ts

@@ -0,0 +1,39 @@
+import { BadRequestException, Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { Label } from './types/label.entity';
+import { CreateLabelDTO } from './dtos/create-label.dto';
+import { isHexColor } from 'class-validator';
+
+@Injectable()
+export class LabelsService {
+  constructor(
+    @InjectRepository(Label)
+    private labelRepository: Repository<Label>,
+  ) {}
+
+  // Creates a new label
+  async createLabel(labelDto: CreateLabelDTO): Promise<Label> {
+    if (!labelDto.name) {
+      throw new BadRequestException("The 'name' field cannot be null");
+    }
+
+    if (!labelDto.color) {
+      throw new BadRequestException("The 'color' field cannot be null");
+    }
+
+    if (!isHexColor(labelDto.color)) {
+      throw new BadRequestException(
+        "The 'color' field must be a valid hex color",
+      );
+    }
+
+    const newLabel = this.labelRepository.create(labelDto);
+    return this.labelRepository.save(newLabel);
+  }
+
+  // Retrieves all labels
+  async getAllLabels(): Promise<Label[]> {
+    return this.labelRepository.find({ relations: ['tasks'] });
+  }
+}