feat: creating error class

src/packages/DAO/elections.dao.ts

@@ -1,12 +1,17 @@
 "use server";
 
 import prisma from "@lib/prisma";
-import { createElectionValidator } from "@packages/dto/elections.dto";
+import {
+  type FindElection,
+  createElectionValidator,
+  electionSchema,
+  updateElectionSchema,
+} from "@packages/dto/elections.dto";
 import type { CreateElection } from "@packages/entities/elections";
+import { BadRequestError, NotFound } from "@packages/utils/error";
 import { ElectionStatus } from "@prisma/client";
 import { revalidatePath } from "next/cache";
 import { redirect } from "next/navigation";
-import { z } from "zod";
 
 export async function getElectionsOptions() {
   const elections = await getElections();
@@ -17,10 +22,6 @@ export async function getElectionsOptions() {
 }
 
 export async function createElection(formData: CreateElection) {
-  const electionSchema = z.object({
-    name: z.string(),
-    candidates: z.array(z.string().uuid()),
-  });
   const parsedFormData = electionSchema.parse(formData);
 
   return await prisma.election.create({
@@ -37,11 +38,14 @@ export async function createElection(formData: CreateElection) {
 
 export async function startElection(formData: FormData) {
   const electionId = String(formData.get("electionId"));
-  const updateElectionSchema = z.string().uuid();
-  const parsedElectionId = updateElectionSchema.parse(electionId);
+  const parsedElectionId = updateElectionSchema.safeParse(electionId);
+
+  if (!parsedElectionId.success) {
+    throw new BadRequestError(parsedElectionId.error.name);
+  }
 
   await prisma.election.update({
-    where: { id: parsedElectionId },
+    where: { id: parsedElectionId.data },
     data: {
       name: "Updated on server",
       status: ElectionStatus.ONGOING,
@@ -51,18 +55,40 @@ export async function startElection(formData: FormData) {
   redirect(`elections/${electionId}`);
 }
 
+async function getElections() {
+  const res = await prisma.election.findMany();
+  if (!res) {
+    throw new NotFound("");
+  }
+  return res;
+}
+
+async function findByNameOrStatus({ name, status }: FindElection) {
+  const resultElection = await getElections();
+  const result = resultElection.find(
+    (e) => e.name === name && e.status === status,
+  );
+  return result;
+}
+
 export async function addElection(formData: FormData) {
   const data = Object.fromEntries(formData);
-  const parsedData = createElectionValidator.parse(data);
+  const parsedData = createElectionValidator.safeParse(data);
+  if (!parsedData.success) {
+    throw new BadRequestError(parsedData.error.name);
+  }
+  const electionExist = await findByNameOrStatus(parsedData.data).catch(
+    (err: Error) => null,
+  );
+  if (electionExist) {
+    throw new BadRequestError(parsedData.data.name);
+  }
+
   await prisma.election.create({
-    data: parsedData,
+    data: parsedData.data,
   });
-
   revalidatePath("/");
 }
-async function getElections() {
-  return await prisma.election.findMany();
-}
 
 // async function updateElection() {
 //   return await prisma.election.findMany();

src/packages/dto/elections.dto.ts

@@ -2,6 +2,20 @@ import { ElectionStatus } from "@prisma/client";
 import { z } from "zod";
 
 export const createElectionValidator = z.object({
-  name: z.string().min(1),
+  name: z
+    .string()
+    .min(5, { message: "O nome de usuário deve ter no mínimo 5 caracteres" })
+    .max(20, { message: "O nome de usuário deve ter no máximo 20 caracteres" }),
   status: z.nativeEnum(ElectionStatus),
 });
+
+export const electionSchema = z.object({
+  name: createElectionValidator.shape.name,
+  candidates: z.array(z.string().uuid({ message: "ID de candidato inválido" })),
+});
+
+export const updateElectionSchema = z
+  .string()
+  .uuid({ message: "ID de eleição inválido" });
+
+export type FindElection = z.infer<typeof createElectionValidator>;

src/packages/utils/error.ts

@@ -0,0 +1,17 @@
+export class NotFound extends Error {
+  public readonly statusCode: number;
+
+  constructor(entity: string) {
+    super(`${entity}: Página não foi encontrada`);
+    this.statusCode = 404;
+  }
+}
+
+export class BadRequestError extends Error {
+  public readonly statusCode: number;
+
+  constructor(data: string) {
+    super(`Este erro ${data} foi encontrado`);
+    this.statusCode = 400;
+  }
+}