[SSF 172] - Food Request Edit & Delete Endpoints

.claude/settings.local.json

@@ -0,0 +1,8 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(grep -E \"\\\\.\\(ts|js\\)$\")",
+      "Bash(yarn test:*)"
+    ]
+  }
+}

apps/backend/src/foodRequests/dtos/update-request.dto.ts

@@ -0,0 +1,25 @@
+import {
+  ArrayNotEmpty,
+  IsEnum,
+  IsNotEmpty,
+  IsOptional,
+  IsString,
+} from 'class-validator';
+import { RequestSize } from '../types';
+import { FoodType } from '../../donationItems/types';
+
+export class UpdateRequestDto {
+  @IsOptional()
+  @IsEnum(RequestSize)
+  requestedSize?: RequestSize;
+
+  @IsOptional()
+  @ArrayNotEmpty()
+  @IsEnum(FoodType, { each: true })
+  requestedFoodTypes?: FoodType[];
+
+  @IsOptional()
+  @IsString()
+  @IsNotEmpty()
+  additionalInformation?: string;
+}

apps/backend/src/foodRequests/request.controller.spec.ts

@@ -3,18 +3,20 @@ import { RequestsController } from './request.controller';
 import { Test, TestingModule } from '@nestjs/testing';
 import { mock } from 'jest-mock-extended';
 import { FoodRequest } from './request.entity';
-import { RequestSize } from './types';
+import { FoodRequestStatus, RequestSize } from './types';
 import { OrderStatus } from '../orders/types';
 import { FoodType } from '../donationItems/types';
 import { OrderDetailsDto } from '../orders/dtos/order-details.dto';
 import { CreateRequestDto } from './dtos/create-request.dto';
+import { UpdateRequestDto } from './dtos/update-request.dto';
 import {
   DonationItemDetailsDto,
   MatchingItemsDto,
   MatchingManufacturersDto,
 } from './dtos/matching.dto';
 import { FoodManufacturer } from '../foodManufacturers/manufacturers.entity';
 import { Pantry } from '../pantries/pantries.entity';
+import { BadRequestException } from '@nestjs/common';
 
 const mockRequestsService = mock<RequestsService>();
 
@@ -44,6 +46,8 @@ describe('RequestsController', () => {
     mockRequestsService.find.mockReset();
     mockRequestsService.create.mockReset();
     mockRequestsService.getOrderDetails.mockReset();
+    mockRequestsService.updateRequest.mockReset();
+    mockRequestsService.delete.mockReset();
 
     const module: TestingModule = await Test.createTestingModule({
       controllers: [RequestsController],
@@ -239,6 +243,118 @@ describe('RequestsController', () => {
     });
   });
 
+  describe('PATCH /:requestId', () => {
+    it('should update request with valid information', async () => {
+      const updatedRequest = {
+        ...foodRequest1,
+        requestedSize: RequestSize.MEDIUM,
+      };
+      mockRequestsService.updateRequest.mockResolvedValue(
+        updatedRequest as FoodRequest,
+      );
+
+      const updateRequestDto: UpdateRequestDto = {
+        requestedSize: RequestSize.MEDIUM,
+      };
+      const result = await controller.updateRequest(1, updateRequestDto);
+
+      expect(result).toEqual(updatedRequest);
+      expect(mockRequestsService.updateRequest).toHaveBeenCalledWith(
+        1,
+        updateRequestDto,
+      );
+    });
+
+    it('should throw BadRequestException when request is not active', async () => {
+      mockRequestsService.updateRequest.mockRejectedValue(
+        new BadRequestException(
+          `Request must be ${FoodRequestStatus.ACTIVE} in order to be updated`,
+        ),
+      );
+
+      const updateRequestDto: UpdateRequestDto = {
+        requestedSize: RequestSize.MEDIUM,
+      };
+
+      await expect(
+        controller.updateRequest(1, updateRequestDto),
+      ).rejects.toThrow(
+        new BadRequestException(
+          `Request must be ${FoodRequestStatus.ACTIVE} in order to be updated`,
+        ),
+      );
+      expect(mockRequestsService.updateRequest).toHaveBeenCalledWith(
+        1,
+        updateRequestDto,
+      );
+    });
+
+    it('should throw BadRequestException when request has orders', async () => {
+      mockRequestsService.updateRequest.mockRejectedValue(
+        new BadRequestException(
+          `Request 2 cannot be updated if it still has orders associated with it`,
+        ),
+      );
+
+      const updateRequestDto: UpdateRequestDto = {
+        requestedSize: RequestSize.MEDIUM,
+      };
+
+      await expect(
+        controller.updateRequest(2, updateRequestDto),
+      ).rejects.toThrow(
+        new BadRequestException(
+          `Request 2 cannot be updated if it still has orders associated with it`,
+        ),
+      );
+      expect(mockRequestsService.updateRequest).toHaveBeenCalledWith(
+        2,
+        updateRequestDto,
+      );
+    });
+  });
+
+  describe('DELETE /:requestId', () => {
+    it('should delete a request by id', async () => {
+      mockRequestsService.delete.mockResolvedValue(undefined);
+
+      const result = await controller.deleteRequest(1);
+
+      expect(result).toBeUndefined();
+      expect(mockRequestsService.delete).toHaveBeenCalledWith(1);
+    });
+
+    it('should throw BadRequestException when request is not active', async () => {
+      mockRequestsService.delete.mockRejectedValue(
+        new BadRequestException(
+          `Request must be ${FoodRequestStatus.ACTIVE} in order to be deleted`,
+        ),
+      );
+
+      await expect(controller.deleteRequest(1)).rejects.toThrow(
+        new BadRequestException(
+          `Request must be ${FoodRequestStatus.ACTIVE} in order to be deleted`,
+        ),
+      );
+      expect(mockRequestsService.delete).toHaveBeenCalledWith(1);
+    });
+
+    it('should throw BadRequestException when request has orders', async () => {
+      mockRequestsService.delete.mockRejectedValue(
+        new BadRequestException(
+          `Request 2 cannot be deleted if it still has orders associated with it`,
+        ),
+      );
+
+      await expect(controller.deleteRequest(2)).rejects.toThrow(
+        new BadRequestException(
+          `Request 2 cannot be deleted if it still has orders associated with it`,
+        ),
+      );
+      expect(mockRequestsService.delete).toHaveBeenCalledWith(2);
+    });
+  });
+
   describe('GET /:requestId/matching-manufacturers/:foodManufacturerId/available-items', () => {
     it('should call requestsService.getAvailableItems and return grouped items', async () => {
       const requestId = 1;

apps/backend/src/foodRequests/request.controller.ts

@@ -6,6 +6,8 @@ import {
   Post,
   Body,
   ValidationPipe,
+  Patch,
+  Delete,
 } from '@nestjs/common';
 import { ApiBody } from '@nestjs/swagger';
 import { RequestsService } from './request.service';
@@ -20,6 +22,7 @@ import {
   MatchingItemsDto,
   MatchingManufacturersDto,
 } from './dtos/matching.dto';
+import { UpdateRequestDto } from './dtos/update-request.dto';
 
 @Controller('requests')
 export class RequestsController {
@@ -108,4 +111,19 @@ export class RequestsController {
       requestData.additionalInformation,
     );
   }
+
+  @Patch('/:requestId')
+  async updateRequest(
+    @Param('requestId', ParseIntPipe) requestId: number,
+    @Body() body: UpdateRequestDto,
+  ): Promise<FoodRequest> {
+    return this.requestsService.updateRequest(requestId, body);
+  }
+
+  @Delete('/:requestId')
+  async deleteRequest(
+    @Param('requestId', ParseIntPipe) requestId: number,
+  ): Promise<void> {
+    return this.requestsService.delete(requestId);
+  }
 }

apps/backend/src/foodRequests/request.service.spec.ts

@@ -11,6 +11,7 @@ import { FoodType } from '../donationItems/types';
 import { DonationItem } from '../donationItems/donationItems.entity';
 import { testDataSource } from '../config/typeormTestDataSource';
 import {
+  BadRequestException,
   InternalServerErrorException,
   NotFoundException,
 } from '@nestjs/common';
@@ -581,4 +582,134 @@ describe('RequestsService', () => {
       );
     });
   });
+
+  describe('updateRequest', () => {
+    it('should update request attributes', async () => {
+      await testDataSource.query(
+        `DELETE FROM allocations WHERE order_id IN (SELECT order_id FROM orders WHERE request_id = 1)`,
+      );
+      await testDataSource.query(`DELETE FROM orders WHERE request_id = 1`);
+
+      const result = await service.updateRequest(1, {
+        requestedSize: RequestSize.MEDIUM,
+      });
+
+      expect(result.requestedSize).toBe(RequestSize.MEDIUM);
+      expect(result.requestedFoodTypes).toEqual([
+        FoodType.SEED_BUTTERS,
+        FoodType.GLUTEN_FREE_BREAD,
+        FoodType.DRIED_BEANS,
+        FoodType.DAIRY_FREE_ALTERNATIVES,
+      ]);
+
+      const fromDb = await testDataSource
+        .getRepository(FoodRequest)
+        .findOneBy({ requestId: 1 });
+      expect(fromDb?.requestedSize).toBe(RequestSize.MEDIUM);
+    });
+
+    it('should throw NotFoundException when request is not found', async () => {
+      await expect(
+        service.updateRequest(9999, { requestedSize: RequestSize.MEDIUM }),
+      ).rejects.toThrow(new NotFoundException('Request 9999 not found'));
+    });
+
+    it('should update all request attributes when all fields are provided', async () => {
+      await testDataSource.query(
+        `DELETE FROM allocations WHERE order_id IN (SELECT order_id FROM orders WHERE request_id = 1)`,
+      );
+      await testDataSource.query(`DELETE FROM orders WHERE request_id = 1`);
+
+      const result = await service.updateRequest(1, {
+        requestedSize: RequestSize.SMALL,
+        requestedFoodTypes: [FoodType.GRANOLA],
+        additionalInformation: 'Updated information',
+      });
+
+      expect(result.requestedSize).toBe(RequestSize.SMALL);
+      expect(result.requestedFoodTypes).toEqual([FoodType.GRANOLA]);
+      expect(result.additionalInformation).toBe('Updated information');
+
+      const fromDb = await testDataSource
+        .getRepository(FoodRequest)
+        .findOneBy({ requestId: 1 });
+      expect(fromDb?.requestedSize).toBe(RequestSize.SMALL);
+      expect(fromDb?.requestedFoodTypes).toEqual([FoodType.GRANOLA]);
+      expect(fromDb?.additionalInformation).toBe('Updated information');
+    });
+
+    it('should throw BadRequestException when request is not active', async () => {
+      await testDataSource.query(
+        `UPDATE food_requests SET status = 'closed' WHERE request_id = 1`,
+      );
+
+      await expect(
+        service.updateRequest(1, { requestedSize: RequestSize.MEDIUM }),
+      ).rejects.toThrow(
+        new BadRequestException(
+          `Request must be ${FoodRequestStatus.ACTIVE} in order to be updated`,
+        ),
+      );
+    });
+
+    it('should throw BadRequestException when request has orders', async () => {
+      await expect(
+        service.updateRequest(2, { requestedSize: RequestSize.MEDIUM }),
+      ).rejects.toThrow(
+        new BadRequestException(
+          `Request 2 cannot be updated if it still has orders associated with it`,
+        ),
+      );
+    });
+
+    it('should throw BadRequestException when all DTO fields are undefined', async () => {
+      await expect(service.updateRequest(1, {})).rejects.toThrow(
+        new BadRequestException(
+          'At least one field must be provided to update',
+        ),
+      );
+    });
+  });
+
+  describe('delete', () => {
+    it('should delete a request by id', async () => {
+      await testDataSource.query(
+        `DELETE FROM allocations WHERE order_id IN (SELECT order_id FROM orders WHERE request_id = 1)`,
+      );
+      await testDataSource.query(`DELETE FROM orders WHERE request_id = 1`);
+
+      await service.delete(1);
+
+      const fromDb = await testDataSource
+        .getRepository(FoodRequest)
+        .findOneBy({ requestId: 1 });
+      expect(fromDb).toBeNull();
+    });
+
+    it('should throw BadRequestException when request is not active', async () => {
+      await testDataSource.query(
+        `UPDATE food_requests SET status = 'closed' WHERE request_id = 1`,
+      );
+
+      await expect(service.delete(1)).rejects.toThrow(
+        new BadRequestException(
+          `Request must be ${FoodRequestStatus.ACTIVE} in order to be deleted`,
+        ),
+      );
+    });
+
+    it('should throw BadRequestException when request has orders', async () => {
+      await expect(service.delete(2)).rejects.toThrow(
+        new BadRequestException(
+          `Request 2 cannot be deleted if it still has orders associated with it`,
+        ),
+      );
+    });
+
+    it('should throw NotFoundException when request is not found', async () => {
+      await expect(service.delete(9999)).rejects.toThrow(
+        new NotFoundException('Request 9999 not found'),
+      );
+    });
+  });
 });