refact: changed relationship of shelter supplies

Author: fagundesjg

prisma/migrations/20240508022250_/migration.sql

@@ -0,0 +1,11 @@
+/*
+  Warnings:
+
+  - You are about to drop the column `shelter_id` on the `supplies` table. All the data in the column will be lost.
+
+*/
+-- DropForeignKey
+ALTER TABLE "supplies" DROP CONSTRAINT "supplies_shelter_id_fkey";
+
+-- AlterTable
+ALTER TABLE "supplies" DROP COLUMN "shelter_id";

prisma/schema.prisma

@@ -70,15 +70,13 @@ model ShelterSupply {
 
 model Supply {
   id               String  @id @default(uuid())
-  shelterId        String  @map("shelter_id")
   supplyCategoryId String  @map("supply_category_id")
   name             String
   priority         Int     @default(value: 0)
   createdAt        String  @map("created_at") @db.VarChar(32)
   updatedAt        String? @map("updated_at") @db.VarChar(32)
 
   supplyCategory  SupplyCategory  @relation(fields: [supplyCategoryId], references: [id])
-  shelter         Shelter         @relation(fields: [shelterId], references: [id])
   shelterSupplies ShelterSupply[]
 
   @@map("supplies")
@@ -99,7 +97,6 @@ model Shelter {
   createdAt       String   @map("created_at") @db.VarChar(32)
   updatedAt       String?  @map("updated_at") @db.VarChar(32)
 
-  supplies        Supply[]
   shelterManagers ShelterManagers[]
   shelterSupplies ShelterSupply[]
 

src/app.module.ts

@@ -10,6 +10,7 @@ import { UsersModule } from './users/users.module';
 import { SessionsModule } from './sessions/sessions.module';
 import { SupplyCategoriesModule } from './supply-categories/supply-categories.module';
 import { ShelterManagersModule } from './shelter-managers/shelter-managers.module';
+import { ShelterSupplyModule } from './shelter-supply/shelter-supply.module';
 
 @Module({
   imports: [
@@ -20,6 +21,7 @@ import { ShelterManagersModule } from './shelter-managers/shelter-managers.modul
     SupplyModule,
     SupplyCategoriesModule,
     ShelterManagersModule,
+    ShelterSupplyModule,
   ],
   controllers: [],
   providers: [

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

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

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

@@ -0,0 +1,70 @@
+import {
+  Body,
+  Controller,
+  Get,
+  HttpException,
+  Logger,
+  Param,
+  Post,
+  Put,
+} from '@nestjs/common';
+import { ApiTags } from '@nestjs/swagger';
+
+import { ShelterSupplyService } from './shelter-supply.service';
+import { ServerResponse } from '../utils';
+
+@ApiTags('Suprimento de abrigos')
+@Controller('shelter/supplies')
+export class ShelterSupplyController {
+  private logger = new Logger(ShelterSupplyController.name);
+
+  constructor(private readonly shelterSupplyService: ShelterSupplyService) {}
+
+  @Get(':shelterId')
+  async index(@Param('shelterId') shelterId: string) {
+    try {
+      const data = await this.shelterSupplyService.index(shelterId);
+      return new ServerResponse(200, 'Successfully get shelter supplies', data);
+    } catch (err: any) {
+      this.logger.error(`Failed to get shelter supplies: ${err}`);
+      throw new HttpException(err?.code ?? err?.name ?? `${err}`, 400);
+    }
+  }
+
+  @Post('')
+  async store(@Body() body) {
+    try {
+      const data = await this.shelterSupplyService.store(body);
+      return new ServerResponse(
+        200,
+        'Successfully created shelter supply',
+        data,
+      );
+    } catch (err: any) {
+      this.logger.error(`Failed to create shelter supply: ${err}`);
+      throw new HttpException(err?.code ?? err?.name ?? `${err}`, 400);
+    }
+  }
+
+  @Put(':shelterId/:supplyId')
+  async update(
+    @Body() body,
+    @Param('shelterId') shelterId: string,
+    @Param('supplyId') supplyId: string,
+  ) {
+    try {
+      const data = await this.shelterSupplyService.update({
+        where: { shelterId, supplyId },
+        data: body,
+      });
+      return new ServerResponse(
+        200,
+        'Successfully updated shelter supply',
+        data,
+      );
+    } catch (err: any) {
+      this.logger.error(`Failed to update shelter supply: ${err}`);
+      throw new HttpException(err?.code ?? err?.name ?? `${err}`, 400);
+    }
+  }
+}

src/shelter-supply/shelter-supply.module.ts

@@ -0,0 +1,12 @@
+import { Module } from '@nestjs/common';
+
+import { ShelterSupplyService } from './shelter-supply.service';
+import { ShelterSupplyController } from './shelter-supply.controller';
+import { PrismaModule } from '../prisma/prisma.module';
+
+@Module({
+  imports: [PrismaModule],
+  providers: [ShelterSupplyService],
+  controllers: [ShelterSupplyController],
+})
+export class ShelterSupplyModule {}

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

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

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

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+import { Injectable } from '@nestjs/common';
+
+import { PrismaService } from '../prisma/prisma.service';
+import { CreateShelterSupplySchema, UpdateShelterSupplySchema } from './types';
+
+@Injectable()
+export class ShelterSupplyService {
+  constructor(private readonly prismaService: PrismaService) {}
+
+  async store(body: z.infer<typeof CreateShelterSupplySchema>) {
+    const payload = CreateShelterSupplySchema.parse(body);
+    await this.prismaService.shelterSupply.create({
+      data: {
+        ...payload,
+        createdAt: new Date().toISOString(),
+      },
+    });
+  }
+
+  async update(body: z.infer<typeof UpdateShelterSupplySchema>) {
+    const { data, where } = UpdateShelterSupplySchema.parse(body);
+    await this.prismaService.shelterSupply.update({
+      where: {
+        shelterId_supplyId: where,
+      },
+      data: {
+        ...data,
+        createdAt: new Date().toISOString(),
+      },
+    });
+  }
+
+  async index(shelterId: string) {
+    return await this.prismaService.shelterSupply.findMany({
+      where: {
+        shelterId,
+      },
+      select: {
+        priority: true,
+        supply: {
+          select: {
+            id: true,
+            name: true,
+            priority: true,
+            supplyCategory: {
+              select: {
+                id: true,
+                name: true,
+              },
+            },
+            updatedAt: true,
+            createdAt: true,
+          },
+        },
+        createdAt: true,
+        updatedAt: true,
+      },
+    });
+  }
+}

src/shelter-supply/types.ts

@@ -0,0 +1,35 @@
+import z from 'zod';
+
+const ShelterSupplySchema = z.object({
+  id: z.string(),
+  shelterId: z.string(),
+  supplyId: z.string(),
+  priority: z.number(),
+  createdAt: z.string(),
+  updatedAt: z.string().nullable().optional(),
+});
+
+const CreateShelterSupplySchema = ShelterSupplySchema.pick({
+  shelterId: true,
+  supplyId: true,
+  priority: true,
+});
+
+const UpdateShelterSupplySchema = z.object({
+  data: z
+    .object({
+      shelterId: z.string(),
+      supplyId: z.string(),
+    })
+    .partial(),
+  where: z.object({
+    shelterId: z.string(),
+    supplyId: z.string(),
+  }),
+});
+
+export {
+  ShelterSupplySchema,
+  CreateShelterSupplySchema,
+  UpdateShelterSupplySchema,
+};