Se crea la lógica para agregar, eliminar y obtener categorías en el front

import { FieldErrors, Resolver, SubmitHandler, useForm } from "react-hook-form";

import { CategoryDatasourceProd } from "../data/datasources/prod/category_datasource"

import { CategoryRepositoryProd } from "../data/repositories/prod/category_repository";

import { Category, CategoryFormValues } from "../infraestructure/entities/category";

import axios, { AxiosError } from "axios";

import { toast } from "react-toastify";

import { Dispatch, SetStateAction, useEffect, useState } from "react";

import { showErrorAxios } from "../utils/Messages";

const categoryDatasource = new CategoryDatasourceProd();

const categoryRepository = new CategoryRepositoryProd(categoryDatasource);

const resolver : Resolver<CategoryFormValues> = async (data) => {

  const errors: FieldErrors<CategoryFormValues> = {};

  if(!data.nameES){

    errors.nameES = {

      type: 'required',

      message: 'El nombre en español de la categoría es requerido'

    }

  }

  if(!data.nameEN){

    errors.nameEN = {

      type: 'required',

      message: 'El nombre en inglés de la categoría es requerido'

    }

  }

  return {

    values: Object.keys(errors).length > 0 ? {} : data,

    errors: errors

  }

}

export const useCategory = (forceRenderList?: () => void, handleClickToClose?: () => void) => {

  const {

    register, 

    handleSubmit,

    setValue,

    formState: {errors},

    clearErrors,

    resetField,

  } = useForm<CategoryFormValues>({resolver});

  const [errorMessage, setErrorMessage] = useState("");

  const [pending, setPending] = useState(false);

  const [isLoading, setIsLoading] = useState(false);

  const [categoriesList, setCategoriesList] = useState<Category[]>([]);

  const onSubmit : SubmitHandler<CategoryFormValues> = (data: CategoryFormValues) => {

    const fetch = async () => {

      try{

        await categoryRepository.registerCategory(data).then(() =>{

          if(forceRenderList && handleClickToClose){

            forceRenderList();

            handleClickToClose();

          }

        });

      }catch(error: any){

        if(axios.isAxiosError(error)){

          error as AxiosError;

          switch(error.code){

            case(axios.AxiosError.ERR_BAD_REQUEST):

              setErrorMessage("Acceso no autorizado");

              break;

            case(axios.AxiosError.ERR_NETWORK):

              setErrorMessage("Conexión con el servidor fallida");

              break;

            default:

              setErrorMessage(error.message);

              break;

          }

        }

        throw new Error();

      }

    }

    toast.promise(

      fetch(),{

        pending: "Subiendo datos...",

        success: "Los datos se han subido correctamente",

        error: errorMessage

      }

    )

  }

  const updateCategoriesList = async () => {

    setPending(true);

    try{

      const categories = await categoryRepository.getCategories();

      setCategoriesList(categories);

      setPending(false);

    }catch(error: any){

      if(axios.isAxiosError(error)){

        error as AxiosError;

        showErrorAxios(error);

      }

      setPending(false);

    }

  }

  useEffect(()=>{

    setIsLoading(true);

    updateCategoriesList();

    setIsLoading(false);

  },[]);

  const deleteCategory = async (category: Category) => {

    setPending(true);

    await categoryRepository.deleteCategory(category);

    const categories = await categoryRepository.getCategories();

    setCategoriesList(categories);

    setPending(false);

  }

  return {

    register, 

    handleSubmit, 

    errors, 

    onSubmit, 

    setValue,

    clearErrors,

    resetField,

    updateCategoriesList,

    categoriesList,

    pending,

    deleteCategory,

    isLoading

  };

}

 No newline at end of file