next-recomponents 2.0.39 → 2.0.41

package/src/use-resources/index.ts

@@ -1,40 +1,9 @@
-import { useCallback, useEffect, useRef, useState } from "react";
+import { useEffect, useMemo, useState } from "react";
 import { EnhancedEndpoints, ItemsRecord, Props, ShowOptions } from "./types";
 import useToken from "./get.token";
 import axios from "axios";
 import httpStatusCodes from "./http.codes";
 
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function getErrorMeaning(error: any): string | undefined {
-  return httpStatusCodes.find((s) => s.code === error?.status)?.meaning;
-}
-
-function mergeDataArray(existing: any[], incoming: any, matchId?: any): any[] {
-  const idx = existing.findIndex((d) => d?.id == matchId);
-  if (idx >= 0) {
-    return existing.map((d, i) => (i === idx ? incoming : d));
-  }
-  return [incoming, ...existing];
-}
-
-// Copia profunda de un solo key para evitar mutación de estado
-function cloneKey<T extends Record<string, any>>(state: T, key: string): T {
-  return {
-    ...state,
-    [key]: {
-      ...state[key],
-      data: state[key]?.data ? [...state[key].data] : [],
-    },
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Hook
-// ---------------------------------------------------------------------------
-
 export default function useResources<T extends Record<string, ItemsRecord>>({
   baseURI,
   endpoints,
@@ -42,389 +11,447 @@ export default function useResources<T extends Record<string, ItemsRecord>>({
 }: Props<T>) {
   const token = useToken();
 
-  const [info, setInfo] = useState<EnhancedEndpoints<T>>(() =>
+  const [info, setInfo] = useState<EnhancedEndpoints<T>>(
     Object.keys(endpoints).reduce((acc: any, key) => {
-      acc[key] = {
-        loaded: false,
-        id: endpoints[key]?.id,
-        defaultParams: endpoints[key]?.defaultParams,
-        data: [],
-        selectedItem: {},
-        state: "success",
-        errorMessage: "",
-      };
-      return acc;
-    }, {} as any),
-  );
-
-  // Ref siempre actualizado → las callbacks leen estado fresco sin re-crearse
-  const infoRef = useRef(info);
-  useEffect(() => {
-    infoRef.current = info;
-  }, [info]);
-
-  // ------------------------------------------------------------------
-  // Funciones de estado auxiliares (no dependen de key en tiempo de cierre)
-  // ------------------------------------------------------------------
-
-  const setKeyLoading = useCallback((key: string) => {
-    setInfo((prev) => ({
-      ...cloneKey(prev, key),
-      [key]: {
-        ...cloneKey(prev, key)[key],
-        state: "loading",
-        errorMessage: "",
-      },
-    }));
-  }, []);
-
-  const setKeyError = useCallback(
-    (key: string, error: any) => {
-      const meaning = getErrorMeaning(error);
-      if (error?.status === 403) onError?.({ error, errorMessage: meaning });
-      setInfo((prev) => ({
-        ...cloneKey(prev, key),
+      const newAcc: any = {
+        ...acc,
         [key]: {
-          ...cloneKey(prev, key)[key],
-          state: "error",
-          errorMessage: meaning || error?.message,
+          loaded: false,
+          id: endpoints[key]?.id,
+          defaultParams: endpoints[key]?.defaultParams,
+          data: [],
+          selectedItem: {},
         },
-      }));
-    },
-    [onError],
-  );
+      };
 
-  // ------------------------------------------------------------------
-  // show
-  // ------------------------------------------------------------------
-
-  const show = useCallback(
-    async (
-      key: string,
-      { limit = 10, page = 1, merge = true, ...query }: ShowOptions,
-    ) => {
-      setInfo((prev) => ({
-        ...cloneKey(prev, key),
-        [key]: {
-          ...cloneKey(prev, key)[key],
-          state: "loading",
-          errorMessage: "",
-          params: query,
-          loaded: true,
-        },
-      }));
+      return newAcc;
+    }, {} as any),
+  );
 
-      try {
-        const { data: res } = await axios.get(`${baseURI}/${key}`, {
+  const results: EnhancedEndpoints<T> = Object.keys(endpoints).reduce(
+    (acc: any, key) => {
+      const endpoint = endpoints[key];
+      const showFunc = async (
+        { limit = 10, page = 1, merge = true, ...query }: ShowOptions,
+        autoLoad: boolean = false,
+      ) => {
+        const options = {
+          method: "GET",
+          url: `${baseURI}/${key}`,
           params: { limit, page, ...query },
           headers: { Authorization: token },
-        });
-
-        setInfo((prev) => {
-          const prevData = prev[key]?.data ?? [];
-          const merged = merge
-            ? page === 1
-              ? res.data
-              : [...prevData, ...res.data]
-            : res.data;
-          return {
-            ...prev,
-            [key]: {
-              ...prev[key],
-              state: "success",
-              errorMessage: "",
-              data: merged,
-              totalItems: res.totalItems,
-              totalPages: res.totalPages,
-              currentPage: res.currentPage,
+        };
+
+        const newInfo = { ...info };
+        // newInfo[key] = newInfo[key] || {};
+        newInfo[key].state = "loading";
+        newInfo[key].errorMessage = "";
+        newInfo[key].params = query;
+        newInfo[key].loaded = true;
+
+        setInfo(newInfo);
+
+        try {
+          const consulta = await axios.request(options);
+          const d = consulta.data;
+          newInfo[key].state = "success";
+          newInfo[key].errorMessage = "";
+
+          newInfo[key].data = merge
+            ? page == 1
+              ? d.data
+              : [...d.data, ...(newInfo[key].data || [])]
+            : d.data;
+          newInfo[key].totalItems = d.totalItems;
+          newInfo[key].totalPages = d.totalPages;
+          newInfo[key].currentPage = d.currentPage;
+
+          setInfo({ ...newInfo });
+          return d.data;
+        } catch (error: any) {
+          const item = httpStatusCodes.find((s) => s.code == error.status);
+
+          newInfo[key].state = "error";
+          newInfo[key].errorMessage = item?.meaning;
+          if (error.status == 403) {
+            onError?.({ error, ...{ errorMessage: item?.meaning } });
+          }
+          setInfo({ ...newInfo });
+          return error;
+        }
+      };
+      const findFunc = async (id: number, query: any) => {
+        const options = {
+          method: "GET",
+          url: `${baseURI}/${key}/${id}`,
+          params: { ...query },
+          headers: { Authorization: token },
+        };
+        const newInfo = { ...info };
+        // newInfo[key] = newInfo[key] || {};
+        newInfo[key].state = "loading";
+        newInfo[key].errorMessage = "";
+        newInfo[key].params = query;
+        newInfo[key].loaded = true;
+
+        setInfo(newInfo);
+
+        try {
+          const consulta = await axios.request(options);
+          const d = consulta.data;
+          newInfo[key].state = "success";
+          newInfo[key].errorMessage = "";
+
+          newInfo[key].selectedItem = d;
+          const index = newInfo[key]?.data?.findIndex((d: any) => d?.id == id);
+
+          if (index >= 0) {
+            newInfo[key].data[index] = d;
+          } else {
+            if (newInfo[key]?.data) {
+              newInfo[key].data.unshift(d);
+            } else {
+              newInfo[key].data = [d];
+            }
+          }
+
+          setInfo({ ...newInfo });
+          return d;
+        } catch (error: any) {
+          const item = httpStatusCodes.find((s) => s.code == error.status);
+
+          newInfo[key].state = "error";
+          newInfo[key].errorMessage = item?.meaning || error.message;
+          if (error.status == 403) {
+            onError?.({ error, ...{ errorMessage: item?.meaning } });
+          }
+          setInfo({ ...newInfo });
+          return error;
+        }
+      };
+      const bodyCreateFunc = async (
+        data: Record<string, any> | Record<string, any>[],
+      ) => {
+        const options = {
+          method: "POST",
+          url: `${baseURI}/${key}`,
+          data: Array.isArray(data) ? [...data] : { ...data },
+          headers: { Authorization: token },
+        };
+        const newInfo = { ...info };
+        // newInfo[key] = newInfo[key] || {};
+        newInfo[key].state = "loading";
+        newInfo[key].errorMessage = "";
+
+        setInfo(newInfo);
+
+        try {
+          const consulta = await axios.request(options);
+          const d = consulta.data;
+          newInfo[key].state = "success";
+          newInfo[key].errorMessage = "";
+          if (Array.isArray(data)) {
+            for (let datum of data) {
+              const index = newInfo[key]?.data?.findIndex(
+                (d: any) => d?.id == datum?.id,
+              );
+              if (index >= 0) {
+                newInfo[key].data[index] = d;
+              } else {
+                if (newInfo[key]?.data) {
+                  newInfo[key].data.unshift(d);
+                } else {
+                  newInfo[key].data = [d];
+                }
+              }
+            }
+            newInfo[key].data = newInfo[key].data.flat();
+          } else {
+            newInfo[key].selectedItem = d;
+            const index = newInfo[key]?.data?.findIndex(
+              (d: any) => d?.id == data?.id,
+            );
+            if (index >= 0) {
+              newInfo[key].data[index] = d;
+            } else {
+              if (newInfo[key]?.data) {
+                newInfo[key].data.unshift(d);
+              } else {
+                newInfo[key].data = [d];
+              }
+            }
+          }
+          setInfo({ ...newInfo });
+          return d;
+        } catch (error: any) {
+          const item = httpStatusCodes.find((s) => s.code == error.status);
+
+          newInfo[key].state = "error";
+          newInfo[key].errorMessage = item?.meaning || error.message;
+          if (error.status == 403) {
+            onError?.({ error, ...{ errorMessage: item?.meaning } });
+          }
+          setInfo({ ...newInfo });
+          return error;
+        }
+      };
+      const formCreateFunc = async (
+        data: Record<string, any> | Record<string, any>[],
+      ) => {
+        const newInfo = { ...info };
+        newInfo[key].state = "loading";
+        newInfo[key].errorMessage = "";
+        setInfo(newInfo);
+
+        try {
+          // Convertir datos a FormData
+          const formData = new FormData();
+
+          if (Array.isArray(data)) {
+            // Suponiendo que la API acepta múltiples entradas con la misma clave
+            data.forEach((item, i) => {
+              for (const [k, v] of Object.entries(item)) {
+                formData.append(`${k}[${i}]`, v as any);
+              }
+            });
+          } else {
+            for (const [k, v] of Object.entries(data)) {
+              formData.append(k, v);
+            }
+          }
+
+          const options = {
+            method: "POST",
+            url: `${baseURI}/${key}`,
+            data: formData,
+            headers: {
+              Authorization: token,
+              "Content-Type": "multipart/form-data",
             },
           };
-        });
 
-        return res.data as any[];
-      } catch (error: any) {
-        setKeyError(key, error);
-        return error;
-      }
-    },
-    [baseURI, token, setKeyError],
-  );
-
-  // ------------------------------------------------------------------
-  // find
-  // ------------------------------------------------------------------
-
-  const find = useCallback(
-    async (key: string, id: number, query?: any) => {
-      setInfo((prev) => ({
-        ...cloneKey(prev, key),
-        [key]: {
-          ...cloneKey(prev, key)[key],
-          state: "loading",
-          errorMessage: "",
-          params: query,
-          loaded: true,
+          const consulta = await axios.request(options);
+          const d = consulta.data;
+
+          newInfo[key].state = "success";
+          newInfo[key].errorMessage = "";
+
+          if (Array.isArray(data)) {
+            for (let datum of data) {
+              const index = newInfo[key]?.data?.findIndex(
+                (d: any) => d?.id == datum?.id,
+              );
+              if (index >= 0) {
+                newInfo[key].data[index] = d;
+              } else {
+                if (newInfo[key]?.data) {
+                  newInfo[key].data.unshift(d);
+                } else {
+                  newInfo[key].data = [d];
+                }
+              }
+            }
+            newInfo[key].data = newInfo[key].data.flat();
+          } else {
+            newInfo[key].selectedItem = d;
+            const index = newInfo[key]?.data?.findIndex(
+              (d: any) => d?.id == data?.id,
+            );
+            if (index >= 0) {
+              newInfo[key].data[index] = d;
+            } else {
+              if (newInfo[key]?.data) {
+                newInfo[key].data.unshift(d);
+              } else {
+                newInfo[key].data = [d];
+              }
+            }
+          }
+
+          setInfo({ ...newInfo });
+          return d;
+        } catch (error: any) {
+          const item = httpStatusCodes.find((s) => s.code == error.status);
+          newInfo[key].state = "error";
+          newInfo[key].errorMessage = item?.meaning || error.message;
+          if (error.status == 403) {
+            onError?.({ error, ...{ errorMessage: item?.meaning } });
+          }
+          setInfo({ ...newInfo });
+          return error;
+        }
+      };
+      acc[key] = {
+        ...endpoint,
+        loaded: false,
+        show: showFunc,
+        find: findFunc,
+        create: async (data: Record<string, any> | Record<string, any>[]) => {
+          const hasFile = Array.isArray(data)
+            ? data.some((item) =>
+                Object.values(item).some((value) => value instanceof File),
+              )
+            : Object.values(data).some((value) => value instanceof File);
+
+          if (hasFile) {
+            return await formCreateFunc(data);
+          }
+
+          return await bodyCreateFunc(data);
         },
-      }));
-
-      try {
-        const { data: d } = await axios.get(`${baseURI}/${key}/${id}`, {
-          params: query,
-          headers: { Authorization: token },
-        });
-
-        setInfo((prev) => ({
-          ...prev,
-          [key]: {
-            ...prev[key],
-            state: "success",
-            errorMessage: "",
-            selectedItem: d,
-            data: mergeDataArray(prev[key]?.data ?? [], d, id),
-          },
-        }));
-
-        return d;
-      } catch (error: any) {
-        setKeyError(key, error);
-        return error;
-      }
-    },
-    [baseURI, token, setKeyError],
-  );
-
-  // ------------------------------------------------------------------
-  // create (body o multipart según contenido)
-  // ------------------------------------------------------------------
-
-  const buildFormData = (
-    data: Record<string, any> | Record<string, any>[],
-  ): FormData => {
-    const fd = new FormData();
-    if (Array.isArray(data)) {
-      data.forEach((item, i) => {
-        Object.entries(item).forEach(([k, v]) =>
-          fd.append(`${k}[${i}]`, v as any),
-        );
-      });
-    } else {
-      Object.entries(data).forEach(([k, v]) => fd.append(k, v));
-    }
-    return fd;
-  };
-
-  const hasFiles = (
-    data: Record<string, any> | Record<string, any>[],
-  ): boolean =>
-    Array.isArray(data)
-      ? data.some((item) => Object.values(item).some((v) => v instanceof File))
-      : Object.values(data).some((v) => v instanceof File);
-
-  const create = useCallback(
-    async (key: string, data: Record<string, any> | Record<string, any>[]) => {
-      setKeyLoading(key);
-
-      const isForm = hasFiles(data);
-      const payload = isForm
-        ? buildFormData(data)
-        : Array.isArray(data)
-          ? [...data]
-          : { ...data };
-
-      const headers: Record<string, string> = { Authorization: token };
-      if (isForm) headers["Content-Type"] = "multipart/form-data";
-
-      try {
-        const { data: d } = await axios.post(`${baseURI}/${key}`, payload, {
-          headers,
-        });
-
-        setInfo((prev) => {
-          const prevData = prev[key]?.data ?? [];
-          // Para arrays el servidor debería devolver el array creado;
-          // si devuelve un solo objeto, lo envolvemos.
-          const incoming: any[] = Array.isArray(d) ? d : [d];
-          const updatedData = incoming.reduce(
-            (acc, item) => mergeDataArray(acc, item, item?.id),
-            [...prevData],
-          );
-
-          return {
-            ...prev,
-            [key]: {
-              ...prev[key],
-              state: "success",
-              errorMessage: "",
-              selectedItem: Array.isArray(data) ? prev[key].selectedItem : d,
-              data: updatedData,
-            },
+        update: async (id: number, data: any) => {
+          const options = {
+            method: "PATCH",
+            url: `${baseURI}/${key}/${id}`,
+            data: Array.isArray(data) ? [...data] : { ...data },
+            headers: { Authorization: token },
           };
-        });
-
-        return d;
-      } catch (error: any) {
-        setKeyError(key, error);
-        return error;
-      }
-    },
-    [baseURI, token, setKeyLoading, setKeyError],
-  );
+          const newInfo = { ...info };
+          // newInfo[key] = newInfo[key] || {};
+          newInfo[key].state = "loading";
+          newInfo[key].errorMessage = "";
+
+          setInfo(newInfo);
+
+          try {
+            const consulta = await axios.request(options);
+            const d = consulta.data;
+            newInfo[key].state = "success";
+            newInfo[key].errorMessage = "";
+            newInfo[key].selectedItem = { ...newInfo[key].selectedItem, ...d };
+            const index = newInfo[key]?.data?.findIndex(
+              (d: any) => d?.id == id,
+            );
+
+            if (index >= 0) {
+              newInfo[key].data[index] = { ...newInfo[key].data[index], ...d };
+            } else {
+              if (newInfo[key]?.data) {
+                newInfo[key].data.unshift(d);
+              } else {
+                newInfo[key].data = [d];
+              }
+            }
+            setInfo({ ...newInfo });
+            return d;
+          } catch (error: any) {
+            const item = httpStatusCodes.find((s) => s.code == error.status);
+
+            newInfo[key].state = "error";
+            newInfo[key].errorMessage = item?.meaning || error.message;
+            if (error.status == 403) {
+              onError?.({ error, ...{ errorMessage: item?.meaning } });
+            }
+            setInfo({ ...newInfo });
+            return error;
+          }
+        },
+        remove: async (id: number) => {
+          const options = {
+            method: "DELETE",
+            url: `${baseURI}/${key}/${id}`,
+            headers: { Authorization: token },
+          };
+          const newInfo = { ...info };
+          // newInfo[key] = newInfo[key] || {};
+          newInfo[key].state = "loading";
+          newInfo[key].errorMessage = "";
+
+          setInfo(newInfo);
+
+          try {
+            const consulta = await axios.request(options);
+            const d = consulta.data;
+            newInfo[key].state = "success";
+            newInfo[key].errorMessage = "";
+            newInfo[key].selectedItem = d;
+            const index = newInfo[key]?.data?.findIndex(
+              (d: any) => d?.id == id,
+            );
+            if (index >= 0) {
+              newInfo[key].data.splice(index, 1);
+            }
+            setInfo({ ...newInfo });
+            return d.data;
+          } catch (error: any) {
+            const item = httpStatusCodes.find((s) => s.code == error.status);
+
+            newInfo[key].state = "error";
+            newInfo[key].errorMessage = item?.meaning || error.message;
+            if (error.status == 403) {
+              onError?.({ error, ...{ errorMessage: item?.meaning } });
+            }
+            setInfo({ ...newInfo });
+            return error;
+          }
+        },
+        totalPages: info[key]?.totalPages,
+        currentPage: info[key]?.currentPage,
+        state: info[key]?.state || "success",
+        errorMessage: info[key]?.errorMessage,
+        params: info[key]?.params,
+        setLoaded: () => {
+          const newInfo = { ...info };
+          newInfo[key].loaded = true;
+          setInfo(newInfo);
+        },
+        getAllPages: async (limit = 100) => {
+          const allData: any[] = [];
+          let currentPage = 1;
+          let totalPages = 1;
+
+          while (currentPage <= totalPages) {
+            const response = await results[key].show({
+              limit,
+              page: currentPage,
+            });
+
+            // Importante: `show` ya actualiza info[key], así que podemos leer desde ahí
+            const currentInfo = info[key];
+
+            if (Array.isArray(response)) {
+              allData.push(...response);
+            }
+
+            currentPage = currentInfo.currentPage || currentPage + 1;
+            totalPages = currentInfo.totalPages || currentPage;
+          }
+
+          const newInfo = { ...info };
+          newInfo[key].data = allData;
+          newInfo[key].currentPage = currentPage;
+          newInfo[key].totalPages = totalPages;
+          setInfo(newInfo);
+
+          return allData;
+        },
+        data: info[key]?.data || [],
+        selectedItem: info[key]?.selectedItem || {},
+      };
 
-  // ------------------------------------------------------------------
-  // update
-  // ------------------------------------------------------------------
-
-  const update = useCallback(
-    async (key: string, id: number, data: any) => {
-      setKeyLoading(key);
-
-      try {
-        const { data: d } = await axios.patch(
-          `${baseURI}/${key}/${id}`,
-          Array.isArray(data) ? [...data] : { ...data },
-          { headers: { Authorization: token } },
-        );
-
-        setInfo((prev) => ({
-          ...prev,
-          [key]: {
-            ...prev[key],
-            state: "success",
-            errorMessage: "",
-            selectedItem: { ...prev[key].selectedItem, ...d },
-            data: mergeDataArray(
-              prev[key]?.data ?? [],
-              { ...prev[key]?.data?.find((i: any) => i?.id == id), ...d },
-              id,
-            ),
-          },
-        }));
-
-        return d;
-      } catch (error: any) {
-        setKeyError(key, error);
-        return error;
-      }
+      return acc;
     },
-    [baseURI, token, setKeyLoading, setKeyError],
+    {},
   );
 
-  // ------------------------------------------------------------------
-  // remove
-  // ------------------------------------------------------------------
-
-  const remove = useCallback(
-    async (key: string, id: number) => {
-      setKeyLoading(key);
-
-      try {
-        const { data: d } = await axios.delete(`${baseURI}/${key}/${id}`, {
-          headers: { Authorization: token },
-        });
-
-        setInfo((prev) => ({
-          ...prev,
-          [key]: {
-            ...prev[key],
-            state: "success",
-            errorMessage: "",
-            selectedItem: d,
-            data: (prev[key]?.data ?? []).filter((item: any) => item?.id != id),
-          },
-        }));
-
-        return d;
-      } catch (error: any) {
-        setKeyError(key, error);
-        return error;
+  async function doSome() {
+    const key = Object.keys(info).find((k) => {
+      return info[k].loaded === false;
+    });
+
+    if (key) {
+      if (info[key]?.id) {
+        await results[key].find(info[key]?.id, info[key]?.defaultParams);
+      } else if (info[key]?.defaultParams) {
+        await results[key].show(info[key]?.defaultParams);
+      } else {
+        results[key].setLoaded();
       }
-    },
-    [baseURI, token, setKeyLoading, setKeyError],
-  );
-
-  // ------------------------------------------------------------------
-  // getAllPages — ya no usa referencia circular a results
-  // ------------------------------------------------------------------
-
-  const getAllPages = useCallback(
-    async (key: string, limit = 100) => {
-      const allData: any[] = [];
-      let page = 1;
-      let totalPages = 1;
-
-      do {
-        const pageData = await show(key, { limit, page, merge: false });
-        if (Array.isArray(pageData)) allData.push(...pageData);
-        // Leer totalPages desde infoRef (siempre fresco)
-        totalPages = infoRef.current[key]?.totalPages ?? page;
-        page++;
-      } while (page <= totalPages);
-
-      setInfo((prev) => ({
-        ...prev,
-        [key]: { ...prev[key], data: allData },
-      }));
-
-      return allData;
-    },
-    [show],
-  );
-
-  // ------------------------------------------------------------------
-  // Auto-load al montar
-  // ------------------------------------------------------------------
-
-  useEffect(() => {
-    const key = Object.keys(info).find((k) => info[k].loaded === false);
-    if (!key) return;
-
-    if (info[key]?.id) {
-      find(key, info[key].id as any, info[key].defaultParams);
-    } else if (info[key]?.defaultParams) {
-      show(key, info[key].defaultParams);
-    } else {
-      setInfo((prev) => ({
-        ...prev,
-        [key]: { ...prev[key], loaded: true },
-      }));
     }
-    // Solo se dispara cuando cambia cuáles keys están cargados
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [
-    Object.keys(info)
-      .map((k) => info[k].loaded)
-      .join(","),
-  ]);
-
-  // ------------------------------------------------------------------
-  // Construir el objeto results que se expone al consumidor
-  // ------------------------------------------------------------------
-
-  const results = Object.keys(endpoints).reduce((acc: any, key) => {
-    const s = info[key];
-    acc[key] = {
-      ...endpoints[key],
-      data: s?.data ?? [],
-      selectedItem: s?.selectedItem ?? {},
-      state: s?.state ?? "success",
-      errorMessage: s?.errorMessage,
-      params: s?.params,
-      totalPages: s?.totalPages,
-      currentPage: s?.currentPage,
-      totalItems: s?.totalItems,
-      loaded: s?.loaded ?? false,
-      show: (opts: ShowOptions) => show(key, opts),
-      find: (id: number, query?: any) => find(key, id, query),
-      create: (data: Record<string, any> | Record<string, any>[]) =>
-        create(key, data),
-      update: (id: number, data: any) => update(key, id, data),
-      remove: (id: number) => remove(key, id),
-      getAllPages: (limit?: number) => getAllPages(key, limit),
-      setLoaded: () =>
-        setInfo((prev) => ({ ...prev, [key]: { ...prev[key], loaded: true } })),
-    };
-    return acc;
-  }, {} as EnhancedEndpoints<T>);
+  }
+  useEffect(() => {
+    doSome();
+  }, [JSON.stringify(Object.values(info).map((v) => v.loaded))]);
 
   return results;
 }