next-recomponents 2.0.38 → 2.0.39

package/src/use-resources/index.ts

@@ -1,9 +1,40 @@
-import { useEffect, useMemo, useState } from "react";
+import { useCallback, useEffect, useRef, 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,
@@ -11,517 +42,389 @@ 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) => {
-      const newAcc: any = {
-        ...acc,
-        [key]: {
-          loaded: false,
-          id: endpoints[key]?.id,
-          defaultParams: endpoints[key]?.defaultParams,
-          data: [],
-          selectedItem: {},
-        },
+      acc[key] = {
+        loaded: false,
+        id: endpoints[key]?.id,
+        defaultParams: endpoints[key]?.defaultParams,
+        data: [],
+        selectedItem: {},
+        state: "success",
+        errorMessage: "",
       };
-
-      return newAcc;
+      return acc;
     }, {} as any),
   );
 
-  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 },
-        };
-
-        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;
-        }
-      };
-      // Helper para actualizar el array sin mutar
-      const mergeDataArray = (
-        existingData: any[] | undefined,
-        newItem: any,
-        matchId?: any,
-      ): any[] => {
-        if (!existingData) return [newItem];
-        const index = existingData.findIndex((d: any) => d?.id == matchId);
-        if (index >= 0) {
-          return existingData.map((d: any, i: number) =>
-            i === index ? newItem : d,
-          );
-        }
-        return [newItem, ...existingData];
-      };
+  // 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),
+        [key]: {
+          ...cloneKey(prev, key)[key],
+          state: "error",
+          errorMessage: meaning || error?.message,
+        },
+      }));
+    },
+    [onError],
+  );
 
-      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 },
-        };
+  // ------------------------------------------------------------------
+  // 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,
+        },
+      }));
 
-        const newInfo = {
-          ...info,
-          [key]: {
-            ...info[key],
-            data: [...(info[key]?.data ?? [])],
-            state: "loading",
-            errorMessage: "",
-          },
-        };
-
-        setInfo(newInfo);
-
-        try {
-          const consulta = await axios.request(options);
-          const d = consulta.data;
-
-          let updatedData: any[];
-
-          if (Array.isArray(data)) {
-            updatedData = [...(newInfo[key]?.data ?? [])];
-            for (const datum of data) {
-              updatedData = mergeDataArray(updatedData, d, datum?.id);
-            }
-            updatedData = updatedData.flat();
-          } else {
-            updatedData = mergeDataArray(
-              newInfo[key]?.data,
-              d,
-              (data as any)?.id,
-            );
-          }
-
-          setInfo({
-            ...newInfo,
+      try {
+        const { data: res } = await axios.get(`${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]: {
-              ...newInfo[key],
+              ...prev[key],
               state: "success",
               errorMessage: "",
-              selectedItem: Array.isArray(data) ? newInfo[key].selectedItem : d,
-              data: updatedData,
+              data: merged,
+              totalItems: res.totalItems,
+              totalPages: res.totalPages,
+              currentPage: res.currentPage,
             },
-          });
-
-          return d;
-        } catch (error: any) {
-          const item = httpStatusCodes.find((s) => s.code == error.status);
+          };
+        });
 
-          if (error.status == 403) {
-            onError?.({ error, errorMessage: item?.meaning });
-          }
+        return res.data as any[];
+      } catch (error: any) {
+        setKeyError(key, error);
+        return error;
+      }
+    },
+    [baseURI, token, setKeyError],
+  );
 
-          setInfo({
-            ...newInfo,
-            [key]: {
-              ...newInfo[key],
-              state: "error",
-              errorMessage: item?.meaning || error.message,
-            },
-          });
+  // ------------------------------------------------------------------
+  // find
+  // ------------------------------------------------------------------
 
-          return error;
-        }
-      };
+  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 formCreateFunc = async (
-        data: Record<string, any> | Record<string, any>[],
-      ) => {
-        const formData = new FormData();
-
-        if (Array.isArray(data)) {
-          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",
-          },
-        };
+      try {
+        const { data: d } = await axios.get(`${baseURI}/${key}/${id}`, {
+          params: query,
+          headers: { Authorization: token },
+        });
 
-        const newInfo = {
-          ...info,
+        setInfo((prev) => ({
+          ...prev,
           [key]: {
-            ...info[key],
-            data: [...(info[key]?.data ?? [])],
-            state: "loading",
+            ...prev[key],
+            state: "success",
             errorMessage: "",
+            selectedItem: d,
+            data: mergeDataArray(prev[key]?.data ?? [], d, id),
           },
-        };
-
-        setInfo(newInfo);
-
-        try {
-          const consulta = await axios.request(options);
-          const d = consulta.data;
-
-          let updatedData: any[];
-
-          if (Array.isArray(data)) {
-            updatedData = [...(newInfo[key]?.data ?? [])];
-            for (const datum of data) {
-              updatedData = mergeDataArray(updatedData, d, datum?.id);
-            }
-            updatedData = updatedData.flat();
-          } else {
-            updatedData = mergeDataArray(
-              newInfo[key]?.data,
-              d,
-              (data as any)?.id,
-            );
-          }
-
-          setInfo({
-            ...newInfo,
+        }));
+
+        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]: {
-              ...newInfo[key],
+              ...prev[key],
               state: "success",
               errorMessage: "",
-              selectedItem: Array.isArray(data) ? newInfo[key].selectedItem : d,
+              selectedItem: Array.isArray(data) ? prev[key].selectedItem : d,
               data: updatedData,
             },
-          });
+          };
+        });
 
-          return d;
-        } catch (error: any) {
-          const item = httpStatusCodes.find((s) => s.code == error.status);
+        return d;
+      } catch (error: any) {
+        setKeyError(key, error);
+        return error;
+      }
+    },
+    [baseURI, token, setKeyLoading, setKeyError],
+  );
 
-          if (error.status == 403) {
-            onError?.({ error, errorMessage: item?.meaning });
-          }
+  // ------------------------------------------------------------------
+  // update
+  // ------------------------------------------------------------------
 
-          setInfo({
-            ...newInfo,
-            [key]: {
-              ...newInfo[key],
-              state: "error",
-              errorMessage: item?.meaning || error.message,
-            },
-          });
+  const update = useCallback(
+    async (key: string, id: number, data: any) => {
+      setKeyLoading(key);
 
-          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);
-        },
-        update: async (id: number, data: any) => {
-          const options = {
-            method: "PATCH",
-            url: `${baseURI}/${key}/${id}`,
-            data: Array.isArray(data) ? [...data] : { ...data },
-            headers: { Authorization: token },
-          };
+      try {
+        const { data: d } = await axios.patch(
+          `${baseURI}/${key}/${id}`,
+          Array.isArray(data) ? [...data] : { ...data },
+          { headers: { Authorization: token } },
+        );
 
-          const newInfo = {
-            ...info,
-            [key]: {
-              ...info[key], // ✅ copia superficial del key
-              data: [...(info[key]?.data ?? [])], // ✅ copia del array
-              state: "loading",
-              errorMessage: "",
-            },
-          };
+        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,
+            ),
+          },
+        }));
 
-          setInfo(newInfo);
-
-          try {
-            const consulta = await axios.request(options);
-            const d = consulta.data;
-
-            const index = newInfo[key]?.data?.findIndex(
-              (item: any) => item?.id == id,
-            );
-
-            const updatedData =
-              index >= 0
-                ? newInfo[key].data.map(
-                    (
-                      item: any,
-                      i: number, // ✅ map en lugar de mutación
-                    ) => (i === index ? { ...item, ...d } : item),
-                  )
-                : newInfo[key]?.data
-                  ? [d, ...newInfo[key].data] // ✅ nuevo array en lugar de unshift
-                  : [d];
-
-            const updatedInfo = {
-              ...newInfo,
-              [key]: {
-                ...newInfo[key],
-                state: "success",
-                errorMessage: "",
-                selectedItem: { ...newInfo[key].selectedItem, ...d },
-                data: updatedData,
-              },
-            };
-
-            setInfo(updatedInfo);
-            return d;
-          } catch (error: any) {
-            const item = httpStatusCodes.find((s) => s.code == error.status);
-
-            setInfo({
-              ...newInfo,
-              [key]: {
-                ...newInfo[key],
-                state: "error",
-                errorMessage: item?.meaning || error.message,
-              },
-            });
-
-            if (error.status == 403) {
-              onError?.({ error, ...{ errorMessage: item?.meaning } });
-            }
-
-            return error;
-          }
-        },
-        remove: async (id: number) => {
-          const options = {
-            method: "DELETE",
-            url: `${baseURI}/${key}/${id}`,
-            headers: { Authorization: token },
-          };
+        return d;
+      } catch (error: any) {
+        setKeyError(key, error);
+        return error;
+      }
+    },
+    [baseURI, token, setKeyLoading, setKeyError],
+  );
 
-          const newInfo = {
-            ...info,
-            [key]: {
-              ...info[key],
-              data: [...(info[key]?.data ?? [])],
-              state: "loading",
-              errorMessage: "",
-            },
-          };
+  // ------------------------------------------------------------------
+  // remove
+  // ------------------------------------------------------------------
 
-          setInfo(newInfo);
-
-          try {
-            const consulta = await axios.request(options);
-            const d = consulta.data;
-
-            setInfo({
-              ...newInfo,
-              [key]: {
-                ...newInfo[key],
-                state: "success",
-                errorMessage: "",
-                selectedItem: d,
-                data:
-                  newInfo[key]?.data?.filter((item: any) => item?.id != id) ??
-                  [], // ✅ filter en lugar de splice
-              },
-            });
-
-            return d.data;
-          } catch (error: any) {
-            const item = httpStatusCodes.find((s) => s.code == error.status);
-
-            if (error.status == 403) {
-              onError?.({ error, errorMessage: item?.meaning });
-            }
-
-            setInfo({
-              ...newInfo,
-              [key]: {
-                ...newInfo[key],
-                state: "error",
-                errorMessage: item?.meaning || error.message,
-              },
-            });
-
-            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 || {},
-      };
+  const remove = useCallback(
+    async (key: string, id: number) => {
+      setKeyLoading(key);
 
-      return acc;
+      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;
+      }
     },
-    {},
+    [baseURI, token, setKeyLoading, setKeyError],
   );
 
-  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();
-      }
-    }
-  }
+  // ------------------------------------------------------------------
+  // 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(() => {
-    doSome();
-  }, [JSON.stringify(Object.values(info).map((v) => v.loaded))]);
+    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>);
 
   return results;
 }