feat: add req body validation & swagger docs to shelter supplies routes

Author: ocsoares

src/shelter-supply/dtos/CreateShelterSupplyDTO.ts

@@ -0,0 +1,47 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { Transform } from 'class-transformer';
+import {
+  IsEnum,
+  IsNotEmpty,
+  IsNumber,
+  IsOptional,
+  IsString,
+  Min,
+} from 'class-validator';
+import { SupplyPriority } from 'src/supply/types';
+
+export class CreateShelterSupplyDTO {
+  constructor() {
+    this.priority = SupplyPriority.UnderControl;
+  }
+
+  @ApiProperty({ type: 'string', example: 'ID do Abrigo' })
+  @IsNotEmpty()
+  @IsString()
+  readonly shelterId = '';
+
+  @ApiProperty({ type: 'string', example: 'ID do Suprimento' })
+  @IsNotEmpty()
+  @IsString()
+  readonly supplyId = '';
+
+  @ApiProperty({
+    description: 'Prioridade de suprimento',
+    enum: SupplyPriority,
+  })
+  @IsNotEmpty()
+  @IsEnum(SupplyPriority)
+  @Transform((value) => Number(value.value))
+  readonly priority: SupplyPriority;
+
+  @ApiProperty({
+    required: false,
+    type: 'number',
+    example: 1,
+  })
+  @IsOptional()
+  @IsNumber()
+  @Min(1)
+  @Transform((value) => Number(value.value))
+  readonly quantity?: number;
+}

src/shelter-supply/dtos/UpdateManyShelterSupplyDTO.ts

@@ -0,0 +1,14 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { ArrayMinSize, IsArray, IsNotEmpty, IsString } from 'class-validator';
+
+export class UpdateManyShelterSupplySchemaDTO {
+  @ApiProperty({
+    type: [String],
+    example: ['ID do Suprimento', 'ID do Suprimento 2'],
+  })
+  @IsArray()
+  @ArrayMinSize(1)
+  @IsNotEmpty()
+  @IsString({ each: true })
+  readonly ids!: string;
+}

src/shelter-supply/dtos/UpdateShelterSupplyDTO.ts

@@ -0,0 +1,27 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { Transform } from 'class-transformer';
+import { IsEnum, IsOptional, IsNumber, Min } from 'class-validator';
+import { SupplyPriority } from 'src/supply/types';
+
+export class UpdateShelterSupplyDTO {
+  @ApiProperty({
+    required: false,
+    description: 'Prioridade de suprimento',
+    enum: SupplyPriority,
+  })
+  @IsOptional()
+  @IsEnum(SupplyPriority)
+  @Transform((value) => Number(value.value))
+  readonly priority?: SupplyPriority;
+
+  @ApiProperty({
+    required: false,
+    type: 'number',
+    example: 1,
+  })
+  @IsOptional()
+  @IsNumber()
+  @Min(1)
+  @Transform((value) => Number(value.value))
+  readonly quantity?: number;
+}

src/shelter-supply/shelter-supply.controller.ts

@@ -9,19 +9,31 @@ import {
   Put,
   UseGuards,
 } from '@nestjs/common';
-import { ApiTags } from '@nestjs/swagger';
+import {
+  ApiBadRequestResponse,
+  ApiBearerAuth,
+  ApiInternalServerErrorResponse,
+  ApiOkResponse,
+  ApiTags,
+  ApiUnauthorizedResponse,
+} from '@nestjs/swagger';
 
 import { ShelterSupplyService } from './shelter-supply.service';
 import { ServerResponse } from '../utils';
 import { DistributionCenterGuard } from '@/guards/distribution-center.guard';
+import { CreateShelterSupplyDTO } from './dtos/CreateShelterSupplyDTO';
+import { UpdateShelterSupplyDTO } from './dtos/UpdateShelterSupplyDTO';
+import { UpdateManyShelterSupplySchemaDTO } from './dtos/UpdateManyShelterSupplyDTO';
 
 @ApiTags('Suprimento de abrigos')
+@ApiInternalServerErrorResponse()
 @Controller('shelter/supplies')
 export class ShelterSupplyController {
   private logger = new Logger(ShelterSupplyController.name);
 
   constructor(private readonly shelterSupplyService: ShelterSupplyService) {}
 
+  @ApiOkResponse()
   @Get(':shelterId')
   async index(@Param('shelterId') shelterId: string) {
     try {
@@ -33,8 +45,10 @@ export class ShelterSupplyController {
     }
   }
 
+  @ApiBadRequestResponse()
+  @ApiOkResponse()
   @Post('')
-  async store(@Body() body) {
+  async store(@Body() body: CreateShelterSupplyDTO) {
     try {
       const data = await this.shelterSupplyService.store(body);
       return new ServerResponse(
@@ -48,17 +62,20 @@ export class ShelterSupplyController {
     }
   }
 
+  @ApiBadRequestResponse()
+  @ApiOkResponse()
   @Put(':shelterId/:supplyId')
   async update(
-    @Body() body,
+    @Body() body: UpdateShelterSupplyDTO,
     @Param('shelterId') shelterId: string,
     @Param('supplyId') supplyId: string,
   ) {
     try {
-      const data = await this.shelterSupplyService.update({
-        where: { shelterId, supplyId },
-        data: body,
-      });
+      const data = await this.shelterSupplyService.update(
+        body,
+        shelterId,
+        supplyId,
+      );
       return new ServerResponse(
         200,
         'Successfully updated shelter supply',
@@ -70,14 +87,18 @@ export class ShelterSupplyController {
     }
   }
 
+  @ApiBearerAuth()
+  @ApiUnauthorizedResponse()
+  @ApiBadRequestResponse()
+  @ApiOkResponse()
   @Put(':shelterId/supplies/many')
   @UseGuards(DistributionCenterGuard)
-  async updateMany(@Body() body, @Param('shelterId') shelterId: string) {
+  async updateMany(
+    @Body() body: UpdateManyShelterSupplySchemaDTO,
+    @Param('shelterId') shelterId: string,
+  ) {
     try {
-      const data = await this.shelterSupplyService.updateMany({
-        shelterId,
-        ...body,
-      });
+      const data = await this.shelterSupplyService.updateMany(body, shelterId);
       return new ServerResponse(
         200,
         'Successfully updated many shelter supplies',

src/shelter-supply/shelter-supply.service.ts

@@ -1,4 +1,3 @@
-import { z } from 'zod';
 import { Injectable } from '@nestjs/common';
 
 import { PrismaService } from '../prisma/prisma.service';
@@ -8,6 +7,9 @@ import {
   UpdateShelterSupplySchema,
 } from './types';
 import { SupplyPriority } from '../supply/types';
+import { CreateShelterSupplyDTO } from './dtos/CreateShelterSupplyDTO';
+import { UpdateShelterSupplyDTO } from './dtos/UpdateShelterSupplyDTO';
+import { UpdateManyShelterSupplySchemaDTO } from './dtos/UpdateManyShelterSupplyDTO';
 
 @Injectable()
 export class ShelterSupplyService {
@@ -31,7 +33,7 @@ export class ShelterSupplyService {
     });
   }
 
-  async store(body: z.infer<typeof CreateShelterSupplySchema>) {
+  async store(body: CreateShelterSupplyDTO) {
     const { shelterId, priority, supplyId, quantity } =
       CreateShelterSupplySchema.parse(body);
     await this.handleUpdateShelterSum(shelterId, 0, priority);
@@ -46,45 +48,58 @@ export class ShelterSupplyService {
     });
   }
 
-  async update(body: z.infer<typeof UpdateShelterSupplySchema>) {
-    const { data, where } = UpdateShelterSupplySchema.parse(body);
-    const { priority, quantity } = data;
+  async update(
+    body: UpdateShelterSupplyDTO,
+    shelterId: string,
+    supplyId: string,
+  ) {
+    const {
+      shelterId: shelterIdParse,
+      supplyId: supplyIdParse,
+      priority,
+      quantity,
+    } = UpdateShelterSupplySchema.parse({ ...body, shelterId, supplyId });
     if (priority !== null && priority !== undefined) {
       const shelterSupply = await this.prismaService.shelterSupply.findFirst({
         where: {
-          shelterId: where.shelterId,
-          supplyId: where.supplyId,
+          shelterId: shelterIdParse,
+          supplyId: supplyIdParse,
         },
         select: {
           priority: true,
         },
       });
+
       if (shelterSupply)
         await this.handleUpdateShelterSum(
-          where.shelterId,
+          shelterIdParse,
           shelterSupply.priority,
           priority,
         );
     }
 
     await this.prismaService.shelterSupply.update({
       where: {
-        shelterId_supplyId: where,
+        shelterId_supplyId: {
+          shelterId: shelterIdParse,
+          supplyId: supplyIdParse,
+        },
       },
       data: {
-        ...data,
+        priority: priority ?? undefined,
         quantity: priority !== SupplyPriority.UnderControl ? quantity : null,
         updatedAt: new Date().toISOString(),
       },
     });
   }
 
-  async updateMany(body: z.infer<typeof UpdateManyShelterSupplySchema>) {
-    const { ids, shelterId } = UpdateManyShelterSupplySchema.parse(body);
+  async updateMany(body: UpdateManyShelterSupplySchemaDTO, shelterId: string) {
+    const { ids, shelterId: shelterIdParsed } =
+      UpdateManyShelterSupplySchema.parse({ ...body, shelterId });
 
     const supplies = await this.prismaService.shelterSupply.findMany({
       where: {
-        shelterId,
+        shelterId: shelterIdParsed,
         supplyId: {
           in: ids,
         },
@@ -99,7 +114,7 @@ export class ShelterSupplyService {
     await this.prismaService.$transaction([
       this.prismaService.shelter.update({
         where: {
-          id: shelterId,
+          id: shelterIdParsed,
         },
         data: {
           prioritySum: {
@@ -110,7 +125,7 @@ export class ShelterSupplyService {
       }),
       this.prismaService.shelterSupply.updateMany({
         where: {
-          shelterId,
+          shelterId: shelterIdParsed,
           supplyId: {
             in: ids,
           },

src/shelter-supply/types.ts

@@ -25,23 +25,18 @@ const CreateShelterSupplySchema = ShelterSupplySchema.pick({
 });
 
 const UpdateShelterSupplySchema = z.object({
-  data: z
-    .object({
-      priority: z.union([
-        z.literal(SupplyPriority.UnderControl),
-        z.literal(SupplyPriority.Remaining),
-        z.literal(SupplyPriority.Needing),
-        z.literal(SupplyPriority.Urgent),
-      ]),
-      quantity: z.number().nullable().optional(),
-      shelterId: z.string(),
-      supplyId: z.string(),
-    })
-    .partial(),
-  where: z.object({
-    shelterId: z.string(),
-    supplyId: z.string(),
-  }),
+  shelterId: z.string(),
+  supplyId: z.string(),
+  priority: z
+    .union([
+      z.literal(SupplyPriority.UnderControl),
+      z.literal(SupplyPriority.Remaining),
+      z.literal(SupplyPriority.Needing),
+      z.literal(SupplyPriority.Urgent),
+    ])
+    .nullable()
+    .optional(),
+  quantity: z.number().nullable().optional(),
 });
 
 const UpdateManyShelterSupplySchema = z.object({