feat: add delete specie use case

Author: ViniciusCestarii

src/modules/pet/routes.ts

@@ -13,6 +13,7 @@ import { updatePet } from "./pets/controllers/update";
 import { deletePetImage } from "./pets/controllers/delete-image";
 import { deletePet } from "./pets/controllers/delete";
 import { deleteBreed } from "./breeds/controllers/delete";
+import { deleteSpecie } from "./species/controllers/delete";
 
 const petRoutes = new Elysia();
 
@@ -31,6 +32,7 @@ petRoutes.group("pet", (app) =>
     .use(findAllBreedsBySpecie)
     .use(createSpecie)
     .use(updateSpecie)
+    .use(deleteSpecie)
     .use(findAllSpecies),
 );
 

src/modules/pet/species/controllers/delete.test.ts

@@ -0,0 +1,83 @@
+import { describe, expect, it } from "bun:test";
+import { app } from "@/app";
+import db from "@/db";
+import { speciesTable } from "../specie";
+import { bearerToken } from "@/test";
+
+describe("Delete specie e2e", () => {
+  it("should delete a specie successfully", async () => {
+    const specie = (
+      await db
+        .insert(speciesTable)
+        .values({
+          name: "Dog",
+        })
+        .returning()
+    )[0];
+
+    const request = new Request(`http://localhost/pet/species/${specie.id}`, {
+      method: "DELETE",
+      headers: {
+        Authorization: bearerToken,
+      },
+    });
+
+    const response = await app.handle(request);
+
+    expect(response.status).toBe(204);
+  });
+
+  it("should return 404 when trying to delete a specie that doesn't exist", async () => {
+    const request = new Request(
+      "http://localhost/pet/species/08cb2572-77d4-4de3-b6f7-97e4b5cd6512",
+      {
+        method: "DELETE",
+        headers: {
+          Authorization: bearerToken,
+        },
+      },
+    );
+
+    const response = await app.handle(request);
+
+    const body = await response.json();
+
+    expect(body.name).toBe("SpecieNotFoundError");
+
+    expect(response.status).toBe(404);
+  });
+
+  it("should return 422 when delete a specie with invalid data", async () => {
+    const request = new Request("http://localhost/pet/species/invalid", {
+      method: "DELETE",
+      headers: {
+        Authorization: bearerToken,
+      },
+    });
+
+    const response = await app.handle(request);
+
+    const body = await response.json();
+
+    expect(body).toBeTruthy();
+
+    expect(response.status).toBe(422);
+  });
+
+  it("should return 401 trying being Unauthorized", async () => {
+    const request = new Request(
+      "http://localhost/pet/species/b56647a9-9f40-4a31-9a58-42634bfff669",
+      {
+        method: "DELETE",
+      },
+    );
+
+    const response = await app.handle(request);
+
+    const body = await response.json();
+
+    expect(body.name).toBe("Unauthorized");
+
+    expect(response.status).toBe(401);
+  });
+});

src/modules/pet/species/controllers/delete.ts

@@ -0,0 +1,72 @@
+import Elysia, { t } from "elysia";
+import { swaggerSpecieSchema } from "../schema";
+import { makeDeleteSpecieUseCase } from "../factories/make-delete";
+import { auth } from "@/utils/auth/plugin";
+import { swaggerUnauthorizedSchema } from "@/modules/auth/users/schema";
+import { swaggerSpecieNotFoundErrorSchema } from "../../shared/schema";
+import { SpecieNotFoundError } from "../../shared/errors/specie-not-found";
+
+export const deleteSpecie = new Elysia()
+  .use(auth())
+  .error({
+    SpecieNotFoundError,
+  })
+  .onError(({ code, error, set }) => {
+    switch (code) {
+      case "SpecieNotFoundError":
+        set.status = "Not Found";
+        return error;
+    }
+  })
+  .delete(
+    "/species/:id",
+    async ({ params, set }) => {
+      const deleteSpecieUseCase = makeDeleteSpecieUseCase();
+
+      await deleteSpecieUseCase.execute(params.id);
+
+      set.status = "No Content";
+    },
+    {
+      auth: true,
+      params: t.Object({
+        id: t.String({
+          format: "uuid",
+        }),
+      }),
+      detail: {
+        summary: "Delete specie",
+        description: "Delete a specie",
+        tags: ["Pet"],
+        responses: {
+          200: {
+            description: "Success",
+            content: {
+              "application/json": {
+                schema: swaggerSpecieSchema,
+              },
+            },
+          },
+          401: {
+            description: "Unauthorized",
+            content: {
+              "application/json": {
+                schema: swaggerUnauthorizedSchema,
+              },
+            },
+          },
+          404: {
+            description: "Specie not found",
+            content: {
+              "application/json": {
+                schema: swaggerSpecieNotFoundErrorSchema,
+              },
+            },
+          },
+          422: {
+            description: "Validation Error",
+          },
+        },
+      },
+    },
+  );

src/modules/pet/species/factories/make-delete.ts

@@ -0,0 +1,9 @@
+import { DrizzleSpeciesRepository } from "../repositories/drizzle-repository";
+import { DeleteSpecieUseCase } from "../use-cases/delete";
+
+export const makeDeleteSpecieUseCase = () => {
+  const drizzleSpeciesRepository = new DrizzleSpeciesRepository();
+  const useCase = new DeleteSpecieUseCase(drizzleSpeciesRepository);
+
+  return useCase;
+};

src/modules/pet/species/repositories/drizzle-repository.ts

@@ -54,4 +54,8 @@ export class DrizzleSpeciesRepository implements SpeciesRepository {
 
     return rows[0];
   }
+
+  async deleteSpecie(id: Specie["id"]): Promise<void> {
+    await db.delete(speciesTable).where(eq(speciesTable.id, id));
+  }
 }

src/modules/pet/species/repositories/in-memory-repository.ts

@@ -39,4 +39,8 @@ export class InMemorySpeciesRepository implements SpeciesRepository {
   async findSpecieByName(name: string): Promise<Specie | null> {
     return this.species.find((specie) => specie.name === name) || null;
   }
+
+  async deleteSpecie(id: Specie["id"]): Promise<void> {
+    this.species = this.species.filter((specie) => specie.id !== id);
+  }
 }

src/modules/pet/species/repository.ts

@@ -6,4 +6,5 @@ export interface SpeciesRepository {
   findAll(): Promise<Specie[]>;
   findSpecieById(id: string): Promise<Specie | null>;
   findSpecieByName(name: string): Promise<Specie | null>;
+  deleteSpecie(id: Specie["id"]): Promise<void>;
 }

src/modules/pet/species/use-cases/delete.test.ts

@@ -0,0 +1,34 @@
+import { InMemorySpeciesRepository } from "../repositories/in-memory-repository";
+import { beforeEach, describe, expect, it } from "bun:test";
+import { UpdateSpecie } from "../types";
+import { SpecieNotFoundError } from "../../shared/errors/specie-not-found";
+import { DeleteSpecieUseCase } from "./delete";
+
+describe("Delete specie use case", () => {
+  let deleteSpecieUseCase: DeleteSpecieUseCase;
+  let inMemorySpeciesRepository: InMemorySpeciesRepository;
+
+  beforeEach(() => {
+    inMemorySpeciesRepository = new InMemorySpeciesRepository();
+    deleteSpecieUseCase = new DeleteSpecieUseCase(inMemorySpeciesRepository);
+  });
+
+  it("should delete a specie", async () => {
+    const specie = await inMemorySpeciesRepository.createSpecie({
+      name: "Dog",
+    });
+
+    expect(deleteSpecieUseCase.execute(specie.id)).resolves.toBeUndefined();
+  });
+
+  it("should throw SpecieNotFoundError when trying to delete a specie that does not exist", async () => {
+    const specie: UpdateSpecie = {
+      id: "123",
+      name: "Dog",
+    };
+
+    expect(deleteSpecieUseCase.execute(specie.id)).rejects.toThrowError(
+      SpecieNotFoundError,
+    );
+  });
+});

src/modules/pet/species/use-cases/delete.ts

@@ -0,0 +1,17 @@
+import { SpecieNotFoundError } from "../../shared/errors/specie-not-found";
+import { SpeciesRepository } from "../repository";
+import { Specie } from "../types";
+
+export class DeleteSpecieUseCase {
+  constructor(private speciesRepository: SpeciesRepository) {}
+
+  async execute(specieId: Specie["id"]): Promise<void> {
+    const specie = await this.speciesRepository.findSpecieById(specieId);
+
+    if (!specie) {
+      throw new SpecieNotFoundError();
+    }
+
+    await this.speciesRepository.deleteSpecie(specieId);
+  }
+}