@dashadmin/dash-axios-hook 1.3.25 → 1.3.26

package/dist/hooks/processAxiosErrorFunction.js

@@ -1 +1,51 @@
-const E=(s,t,n="update")=>{t||(t="");const c={update:"Actualizar",create:"Crear",delete:"Eliminar"},a=s.response?.data?.message||s.message||"Error al "+(c[n]||n)+" el recurso",i=s.response?.status||500;let e={errors:{}};if(s.response?.data?.errors){const o=s.response.data.errors;Object.keys(o).forEach(r=>{typeof o[r]=="string"?e.errors[r]=o[r]:Array.isArray(o[r])?e.errors[r]=o[r].join(", "):typeof o[r]=="object"&&(e.errors[r]=o[r])}),a&&(e.errors.root={serverError:a})}const u={message:a,status:i,body:e,resource:t,originalError:s,name:"Error"};return console.error("Update error:",{resource:t,errorMessage:a,status:i,validationErrors:e.errors,originalError:s}),u};var l=E;export{l as default};
+const processAxiosError = (error, resource, method = "update") => {
+  var _a, _b, _c, _d, _e;
+  if (!resource) resource = "";
+  const methodMap = {
+    "update": "Actualizar",
+    "create": "Crear",
+    "delete": "Eliminar"
+  };
+  const errorMessage = ((_b = (_a = error.response) == null ? void 0 : _a.data) == null ? void 0 : _b.message) || error.message || "Error al " + (methodMap[method] || method) + " el recurso";
+  const status = ((_c = error.response) == null ? void 0 : _c.status) || 500;
+  let body = {
+    errors: {}
+  };
+  if ((_e = (_d = error.response) == null ? void 0 : _d.data) == null ? void 0 : _e.errors) {
+    const validationErrors = error.response.data.errors;
+    Object.keys(validationErrors).forEach((field) => {
+      if (typeof validationErrors[field] === "string") {
+        body.errors[field] = validationErrors[field];
+      } else if (Array.isArray(validationErrors[field])) {
+        body.errors[field] = validationErrors[field].join(", ");
+      } else if (typeof validationErrors[field] === "object") {
+        body.errors[field] = validationErrors[field];
+      }
+    });
+    if (errorMessage) {
+      body.errors["root"] = {
+        serverError: errorMessage
+      };
+    }
+  }
+  const enhancedError = {
+    message: errorMessage,
+    status,
+    body,
+    resource,
+    originalError: error,
+    name: "Error"
+  };
+  console.error("Update error:", {
+    resource,
+    errorMessage,
+    status,
+    validationErrors: body.errors,
+    originalError: error
+  });
+  return enhancedError;
+};
+var processAxiosErrorFunction_default = processAxiosError;
+export {
+  processAxiosErrorFunction_default as default
+};

package/dist/hooks/useAxios.js

@@ -1 +1,199 @@
-import A from"axios";import{DASHAdminSystemConstants as l}from"@dashadmin/dash-constants";import{dashStorage as u}from"@dashadmin/dash-utils";import y from"./processAxiosErrorFunction";let f=!1,h=[];const d=(s,r=null)=>{h.forEach(a=>{s?a.reject(s):a.resolve(r)}),h=[]},k=async s=>{const r=u.getItem("refreshToken");if(!r)return console.log("[Axios] No refresh token available"),null;try{console.log("[Axios] Attempting to refresh access token...");const i=await A.create({baseURL:l.system.ADMIN_API_URL,headers:{"Content-Type":"application/json",Accept:"application/json"}}).post("/auth/refresh",{refresh_token:r});if(i.status===200&&i.data.token){const o=i.data.token,e=i.data.refresh_token;return u.setItem("token",o),e&&u.setItem("refreshToken",e),console.log("[Axios] Token refresh successful"),o}return null}catch(a){return console.error("[Axios] Token refresh failed:",a),null}},g=()=>{console.log("[Axios] Logging out due to authentication failure");debugger;u.clear(),localStorage.clear(),window.dispatchEvent(new CustomEvent("auth:logout",{detail:{reason:"token_refresh_failed"}}))},p=(s,r)=>{const a=typeof navigator<"u"&&navigator.language?navigator.language.split("-")[0]:"es",i={headers:{"Content-Type":"application/json","Accept-Language":"es",Accept:"application/json"},...s},o=A.create(i);return r&&(o.defaults.withCredentials=!0,o.get("/csrf-cookie").then(e=>{console.log("sanctum",e)})),o.interceptors.request.use(function(e){const t=u.getItem("token");t!==void 0&&t!=="undefined"&&(e.headers.Authorization="Bearer "+t);const c=u.getItem("active_tenant_id");return c&&(e.headers["X-Tenant-Id"]=c),e}),o.interceptors.response.use(e=>e,async e=>{const t=e.config;if(e.response?.status===401&&!t._retry){if(t.url?.includes("/login")||t.url?.includes("/auth/refresh")||t.url?.includes("/logout"))return Promise.reject(e);if(f)return new Promise((n,x)=>{h.push({resolve:n,reject:x})}).then(n=>(n&&t.headers&&(t.headers.Authorization=`Bearer ${n}`),o(t))).catch(n=>Promise.reject(n));t._retry=!0,f=!0;try{const n=await k(o);return n?(t.headers&&(t.headers.Authorization=`Bearer ${n}`),d(null,n),o(t)):(d(e,null),g(),Promise.reject(e))}catch(n){return d(n,null),g(),Promise.reject(n)}finally{f=!1}}return window.dispatchEvent(new MessageEvent("DASHGlobalError",{data:y(e,null,"list"),origin:"AxiosInterceptor"})),Promise.reject(e)}),o},m=s=>p({baseURL:l.system.ADMIN_API_URL,...s&&{...s}}),b=s=>p({baseURL:l.system.ADMIN_API_URL,...s&&{...s}});var D=m;export{b as createAxiosInstance,D as default,p as initAxios,m as useAxios};
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import axios from "axios";
+import { DASHAdminSystemConstants } from "dash-constants";
+import { dashStorage } from "dash-utils";
+import processAxiosError from "./processAxiosErrorFunction";
+let isRefreshing = false;
+let failedQueue = [];
+const processQueue = (error, token = null) => {
+  failedQueue.forEach((prom) => {
+    if (error) {
+      prom.reject(error);
+    } else {
+      prom.resolve(token);
+    }
+  });
+  failedQueue = [];
+};
+const refreshAccessToken = (axiosInstance) => __async(null, null, function* () {
+  const refreshToken = dashStorage.getItem("refreshToken");
+  if (!refreshToken) {
+    console.log("[Axios] No refresh token available");
+    return null;
+  }
+  try {
+    console.log("[Axios] Attempting to refresh access token...");
+    const refreshAxios = axios.create({
+      baseURL: DASHAdminSystemConstants.system.ADMIN_API_URL,
+      headers: {
+        "Content-Type": "application/json",
+        "Accept": "application/json"
+      }
+    });
+    const response = yield refreshAxios.post("/auth/refresh", {
+      refresh_token: refreshToken
+    });
+    if (response.status === 200 && response.data.token) {
+      const newToken = response.data.token;
+      const newRefreshToken = response.data.refresh_token;
+      dashStorage.setItem("token", newToken);
+      if (newRefreshToken) {
+        dashStorage.setItem("refreshToken", newRefreshToken);
+      }
+      console.log("[Axios] Token refresh successful");
+      return newToken;
+    }
+    return null;
+  } catch (error) {
+    console.error("[Axios] Token refresh failed:", error);
+    return null;
+  }
+});
+const handleLogout = () => {
+  console.log("[Axios] Logging out due to authentication failure");
+  debugger;
+  dashStorage.clear();
+  localStorage.clear();
+  window.dispatchEvent(new CustomEvent("auth:logout", {
+    detail: { reason: "token_refresh_failed" }
+  }));
+};
+const initAxios = (options, CSRFAuth) => {
+  const browserLanguage = typeof navigator !== "undefined" && navigator.language ? navigator.language.split("-")[0] : "es";
+  const _options = __spreadValues({
+    headers: {
+      "Content-Type": "application/json",
+      //'Accept-Language': browserLanguage || 'es', // fallback to 'es' if not available
+      "Accept-Language": "es",
+      Accept: "application/json"
+    }
+  }, options);
+  const instance = axios.create(_options);
+  if (CSRFAuth) {
+    instance.defaults.withCredentials = true;
+    instance.get("/csrf-cookie").then((response) => {
+      console.log("sanctum", response);
+    });
+  }
+  instance.interceptors.request.use(function(config) {
+    const token = dashStorage.getItem("token");
+    if (token !== void 0 && token !== "undefined") {
+      config.headers.Authorization = "Bearer " + token;
+    }
+    const activeTenantId = dashStorage.getItem("active_tenant_id");
+    if (activeTenantId) {
+      config.headers["X-Tenant-Id"] = activeTenantId;
+    }
+    return config;
+  });
+  instance.interceptors.response.use(
+    (response) => {
+      return response;
+    },
+    (error) => __async(null, null, function* () {
+      var _a, _b, _c, _d;
+      const originalRequest = error.config;
+      if (((_a = error.response) == null ? void 0 : _a.status) === 401 && !originalRequest._retry) {
+        const isAuthEndpoint = ((_b = originalRequest.url) == null ? void 0 : _b.includes("/login")) || ((_c = originalRequest.url) == null ? void 0 : _c.includes("/auth/refresh")) || ((_d = originalRequest.url) == null ? void 0 : _d.includes("/logout"));
+        if (isAuthEndpoint) {
+          return Promise.reject(error);
+        }
+        if (isRefreshing) {
+          return new Promise((resolve, reject) => {
+            failedQueue.push({ resolve, reject });
+          }).then((token) => {
+            if (token && originalRequest.headers) {
+              originalRequest.headers.Authorization = `Bearer ${token}`;
+            }
+            return instance(originalRequest);
+          }).catch((err) => {
+            return Promise.reject(err);
+          });
+        }
+        originalRequest._retry = true;
+        isRefreshing = true;
+        try {
+          const newToken = yield refreshAccessToken(instance);
+          if (newToken) {
+            if (originalRequest.headers) {
+              originalRequest.headers.Authorization = `Bearer ${newToken}`;
+            }
+            processQueue(null, newToken);
+            return instance(originalRequest);
+          } else {
+            processQueue(error, null);
+            handleLogout();
+            return Promise.reject(error);
+          }
+        } catch (refreshError) {
+          processQueue(refreshError, null);
+          handleLogout();
+          return Promise.reject(refreshError);
+        } finally {
+          isRefreshing = false;
+        }
+      }
+      window.dispatchEvent(
+        new MessageEvent("DASHGlobalError", {
+          data: processAxiosError(error, null, "list"),
+          origin: "AxiosInterceptor"
+        })
+      );
+      return Promise.reject(error);
+    })
+  );
+  return instance;
+};
+const useAxios = (options) => {
+  const a = initAxios(__spreadValues({
+    baseURL: DASHAdminSystemConstants.system.ADMIN_API_URL
+  }, options && __spreadValues({}, options)));
+  return a;
+};
+const createAxiosInstance = (options) => {
+  return initAxios(__spreadValues({
+    baseURL: DASHAdminSystemConstants.system.ADMIN_API_URL
+  }, options && __spreadValues({}, options)));
+};
+var useAxios_default = useAxios;
+export {
+  createAxiosInstance,
+  useAxios_default as default,
+  initAxios,
+  useAxios
+};

package/dist/hooks/useAxiosWithStore.js

@@ -1 +1,63 @@
-import{useEffect as y,useState as u}from"react";import{useStore as m}from"react-admin";import x from"./useAxios";const p=(e,o,a)=>o.split(".").reduce((s,i)=>s?s[i]:a,e),S=e=>{const{storeKey:o,dataPath:a="data"}=e,s=x(),[i,c]=u(null),[d,f]=u(!1),[l,h]=m(o,null),n=async r=>{try{const t=await s({method:r.method,url:`${r.url}${r.payload?"?"+r.payload:""}`});(t.status>=200||t.status<300)&&h(p(t,a,null))}catch(t){c(t)}finally{f(!0)}};return y(()=>{l||n(e)},[]),{request:n,results:l,error:i,loaded:d}};var W=S;export{W as default};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { useEffect, useState } from "react";
+import { useStore } from "react-admin";
+import useAxios from "./useAxios";
+const resolveObjectPath = (object, path, defaultValue) => path.split(".").reduce((o, p) => o ? o[p] : defaultValue, object);
+const useAxiosGetWithStore = (options) => {
+  const {
+    /*method = 'GET',
+    url,
+    payload = null,*/
+    storeKey,
+    dataPath = "data"
+  } = options;
+  const axios = useAxios();
+  const [error, setError] = useState(null);
+  const [loaded, setLoaded] = useState(false);
+  const [results, setResults] = useStore(storeKey, null);
+  const request = (ops) => __async(null, null, function* () {
+    try {
+      const response = yield axios({
+        method: ops.method,
+        url: `${ops.url}${ops.payload ? "?" + ops.payload : ""}`
+      });
+      if (response.status >= 200 || response.status < 300) {
+        setResults(resolveObjectPath(response, dataPath, null));
+      }
+    } catch (e) {
+      setError(e);
+    } finally {
+      setLoaded(true);
+    }
+  });
+  useEffect(() => {
+    if (!results) {
+      request(options);
+    } else {
+    }
+  }, []);
+  return { request, results, error, loaded };
+};
+var useAxiosWithStore_default = useAxiosGetWithStore;
+export {
+  useAxiosWithStore_default as default
+};

package/dist/index.js

@@ -1,154 +1,9 @@
-import k from "axios";
-import { DASHAdminSystemConstants as A } from "@dashadmin/dash-constants";
-import { dashStorage as l } from "@dashadmin/dash-utils";
-import { useState as y, useEffect as v } from "react";
-import { useStore as I } from "react-admin";
-const _ = (t, n, a = "update") => {
-  n || (n = "");
-  const s = {
-    update: "Actualizar",
-    create: "Crear",
-    delete: "Eliminar"
-  }, e = t.response?.data?.message || t.message || "Error al " + (s[a] || a) + " el recurso", r = t.response?.status || 500;
-  let i = {
-    errors: {}
-  };
-  if (t.response?.data?.errors) {
-    const c = t.response.data.errors;
-    Object.keys(c).forEach((u) => {
-      typeof c[u] == "string" ? i.errors[u] = c[u] : Array.isArray(c[u]) ? i.errors[u] = c[u].join(", ") : typeof c[u] == "object" && (i.errors[u] = c[u]);
-    }), e && (i.errors.root = {
-      serverError: e
-    });
-  }
-  const o = {
-    message: e,
-    status: r,
-    body: i,
-    resource: n,
-    originalError: t,
-    name: "Error"
-  };
-  return console.error("Update error:", {
-    resource: n,
-    errorMessage: e,
-    status: r,
-    validationErrors: i.errors,
-    originalError: t
-  }), o;
-};
-let d = !1, g = [];
-const p = (t, n = null) => {
-  g.forEach((a) => {
-    t ? a.reject(t) : a.resolve(n);
-  }), g = [];
-}, j = async (t) => {
-  const n = l.getItem("refreshToken");
-  if (!n)
-    return console.log("[Axios] No refresh token available"), null;
-  try {
-    console.log("[Axios] Attempting to refresh access token...");
-    const s = await k.create({
-      baseURL: A.system.ADMIN_API_URL,
-      headers: {
-        "Content-Type": "application/json",
-        Accept: "application/json"
-      }
-    }).post("/auth/refresh", {
-      refresh_token: n
-    });
-    if (s.status === 200 && s.data.token) {
-      const e = s.data.token, r = s.data.refresh_token;
-      return l.setItem("token", e), r && l.setItem("refreshToken", r), console.log("[Axios] Token refresh successful"), e;
-    }
-    return null;
-  } catch (a) {
-    return console.error("[Axios] Token refresh failed:", a), null;
-  }
-}, E = () => {
-  console.log("[Axios] Logging out due to authentication failure");
-  debugger;
-  l.clear(), localStorage.clear(), window.dispatchEvent(new CustomEvent("auth:logout", {
-    detail: { reason: "token_refresh_failed" }
-  }));
-}, x = (t, n) => {
-  typeof navigator < "u" && navigator.language && navigator.language.split("-")[0];
-  const a = {
-    headers: {
-      "Content-Type": "application/json",
-      //'Accept-Language': browserLanguage || 'es', // fallback to 'es' if not available
-      "Accept-Language": "es",
-      Accept: "application/json"
-    },
-    ...t
-  }, s = k.create(a);
-  return s.interceptors.request.use(function(e) {
-    const r = l.getItem("token");
-    r !== void 0 && r !== "undefined" && (e.headers.Authorization = "Bearer " + r);
-    const i = l.getItem("active_tenant_id");
-    return i && (e.headers["X-Tenant-Id"] = i), e;
-  }), s.interceptors.response.use(
-    (e) => e,
-    async (e) => {
-      const r = e.config;
-      if (e.response?.status === 401 && !r._retry) {
-        if (r.url?.includes("/login") || r.url?.includes("/auth/refresh") || r.url?.includes("/logout"))
-          return Promise.reject(e);
-        if (d)
-          return new Promise((o, c) => {
-            g.push({ resolve: o, reject: c });
-          }).then((o) => (o && r.headers && (r.headers.Authorization = `Bearer ${o}`), s(r))).catch((o) => Promise.reject(o));
-        r._retry = !0, d = !0;
-        try {
-          const o = await j(s);
-          return o ? (r.headers && (r.headers.Authorization = `Bearer ${o}`), p(null, o), s(r)) : (p(e, null), E(), Promise.reject(e));
-        } catch (o) {
-          return p(o, null), E(), Promise.reject(o);
-        } finally {
-          d = !1;
-        }
-      }
-      return window.dispatchEvent(
-        new MessageEvent("DASHGlobalError", {
-          data: _(e, null, "list"),
-          origin: "AxiosInterceptor"
-        })
-      ), Promise.reject(e);
-    }
-  ), s;
-}, w = (t) => x({
-  baseURL: A.system.ADMIN_API_URL,
-  ...t && { ...t }
-}), U = (t) => x({
-  baseURL: A.system.ADMIN_API_URL,
-  ...t && { ...t }
-}), T = (t, n, a) => n.split(".").reduce((s, e) => s ? s[e] : a, t), C = (t) => {
-  const {
-    /*method = 'GET',
-    url,
-    payload = null,*/
-    storeKey: n,
-    dataPath: a = "data"
-  } = t, s = w(), [e, r] = y(null), [i, o] = y(!1), [c, u] = I(n, null), m = async (h) => {
-    try {
-      const f = await s({
-        method: h.method,
-        url: `${h.url}${h.payload ? "?" + h.payload : ""}`
-      });
-      (f.status >= 200 || f.status < 300) && u(T(f, a, null));
-    } catch (f) {
-      r(f);
-    } finally {
-      o(!0);
-    }
-  };
-  return v(() => {
-    c || m(t);
-  }, []), { request: m, results: c, error: e, loaded: i };
-};
+import { default as default2, createAxiosInstance } from "./hooks/useAxios";
+import { default as default3 } from "./hooks/useAxiosWithStore";
+import { default as default4 } from "./hooks/processAxiosErrorFunction";
 export {
-  U as createAxiosInstance,
-  _ as processAxiosError,
-  w as useAxios,
-  C as useAxiosGetWithStore
+  createAxiosInstance,
+  default4 as processAxiosError,
+  default2 as useAxios,
+  default3 as useAxiosGetWithStore
 };

package/package.json

@@ -1,53 +1,63 @@
 {
-  "name": "@dashadmin/dash-axios-hook",
-  "version": "1.3.25",
-  "private": false,
-  "license": "MIT",
-  "main": "dist/index.js",
-  "devDependencies": {
-    "@commitlint/cli": "latest",
-    "@commitlint/config-conventional": "latest",
-    "@types/jest": "latest",
-    "@types/node": "latest",
-    "@types/react": "latest",
-    "@types/react-dom": "latest",
-    "@typescript-eslint/eslint-plugin": "latest",
-    "@typescript-eslint/parser": "latest",
-    "eslint-config-airbnb-typescript": "latest",
-    "eslint-config-prettier": "latest",
-    "eslint-plugin-html": "latest",
-    "eslint-plugin-import": "latest",
-    "eslint-plugin-jsdoc": "latest",
-    "eslint-plugin-json": "latest",
-    "eslint-plugin-prettier": "latest",
-    "ts-jest": "latest",
-    "ts-loader": "latest",
-    "tsconfig-paths": "latest",
-    "typescript": "latest",
-    "vite": "^5.2.0",
-    "rollup": "^4.0.0"
-  },
-  "dependencies": {
-    "@mui/material": "^7.3.10",
-    "@dashadmin/dash-constants": "1.3.25",
-    "@dashadmin/dash-utils": "1.3.25"
-  },
-  "publishConfig": {
-    "name": "@dashadmin/dash-axios-hook",
-    "access": "public"
-  },
-  "files": [
-    "dist"
-  ],
-  "exports": {
-    ".": {
-      "import": "./dist/index.js"
-    },
-    "./src/*": {
-      "import": "./dist/*.js"
-    }
-  },
-  "scripts": {
-    "build": "rm -rf dist && node ../dash-build/compile.mjs && vite build"
-  }
-}
+	"name": "@dashadmin/dash-axios-hook",
+	"version": "1.3.26",
+	"license": "MIT",
+	"main": "dist/index.js",
+	"devDependencies": {
+		"@commitlint/cli": "latest",
+		"@commitlint/config-conventional": "latest",
+		"@types/jest": "latest",
+		"@types/node": "latest",
+		"@types/react": "latest",
+		"@types/react-dom": "latest",
+		"@typescript-eslint/eslint-plugin": "latest",
+		"@typescript-eslint/parser": "latest",
+		"eslint-config-airbnb-typescript": "latest",
+		"eslint-config-prettier": "latest",
+		"eslint-plugin-html": "latest",
+		"eslint-plugin-import": "latest",
+		"eslint-plugin-jsdoc": "latest",
+		"eslint-plugin-json": "latest",
+		"eslint-plugin-prettier": "latest",
+		"ts-jest": "latest",
+		"ts-loader": "latest",
+		"tsconfig-paths": "latest",
+		"typescript": "latest"
+	},
+	"dependencies": {
+		"@mui/material": "^7.3.10",
+		"@dashadmin/dash-constants": "workspace:*",
+		"@dashadmin/dash-utils": "workspace:*"
+	},
+	"module": "dist/index.js",
+	"types": "./src/index.tsx",
+	"exports": {
+		".": "./dist/index.js",
+		"./*": "./dist/*.js",
+		"./src/*": "./dist/*.js"
+	},
+	"publishConfig": {
+		"access": "public",
+		"registry": "https://registry.npmjs.org"
+	},
+	"scripts": {
+		"build": "tsup"
+	},
+	"type": "module",
+	"files": [
+		"dist",
+		"src"
+	],
+	"typesVersions": {
+		"*": {
+			"src/*": [
+				"src/*",
+				"src/*/index"
+			],
+			"*": [
+				"src/*",
+				"src/*/index"
+			]
+		}
+	}
+}

package/src/hooks/processAxiosErrorFunction.tsx

@@ -0,0 +1,73 @@
+import { AxiosError } from 'axios';
+import { IDashAutoAdminBackendError,IDashAutoAdminDefaultBackendStructure } from '../interfaces/IDashAutoAdminBackendError';
+
+
+const processAxiosError = (error:AxiosError<IDashAutoAdminDefaultBackendStructure>,resource?:string,method:string='update') => {
+
+  if(!resource) resource = ""
+  // Map method to Spanish action words
+  const methodMap = {
+      'update': 'Actualizar',
+      'create': 'Crear',
+      'delete': 'Eliminar'
+  };
+
+  // Extract error details
+  const errorMessage = error.response?.data?.message ||  error.message ||  'Error al '+ (methodMap[method] || method) +' el recurso';
+  // Get HTTP status or fallback to 500
+  const status = error.response?.status || 500;
+
+  // If validation errors exist, format them for React Admin
+  let body = {
+      errors: {}
+  };
+
+  if (error.response?.data?.errors) {
+
+   
+      // Format Laravel validation errors for React Admin
+      const validationErrors = error.response.data.errors;
+      Object.keys(validationErrors).forEach(field => {
+          if (typeof validationErrors[field] === 'string') {
+              body.errors[field] = validationErrors[field];
+          } else if (Array.isArray(validationErrors[field])) {
+              body.errors[field] = validationErrors[field].join(', ');
+          } else if (typeof validationErrors[field] === 'object') {
+              body.errors[field] = validationErrors[field];
+          }
+      });
+
+      // Add global validation error if exists
+      if (errorMessage) {
+          body.errors["root"] = {
+              serverError: errorMessage
+          };
+      }
+  }
+
+  // Create an enhanced error object that React Admin can understand
+  const enhancedError = {
+      message: errorMessage,
+      status: status,
+      body: body,
+      resource: resource,
+      originalError: error,
+      name: 'Error'
+  } as IDashAutoAdminBackendError;
+
+    // Log for debugging
+    console.error('Update error:', {
+      resource,
+      errorMessage,
+      status,
+      validationErrors: body.errors,
+      originalError: error
+  });
+
+
+
+  return enhancedError;
+
+}
+
+export default processAxiosError;

package/src/hooks/useAxios.tsx

@@ -0,0 +1,236 @@
+import axios, { Axios, AxiosError, AxiosRequestConfig, AxiosResponse, InternalAxiosRequestConfig } from 'axios';
+
+import {DASHAdminSystemConstants} from  'dash-constants'
+
+import { dashStorage } from 'dash-utils';
+
+import processAxiosError from './processAxiosErrorFunction';
+import { IDashAutoAdminDefaultBackendStructure } from '../interfaces/IDashAutoAdminBackendError';
+
+//import { getCookie } from '../utils/cookies';
+
+// Flag to prevent multiple simultaneous refresh requests
+let isRefreshing = false;
+// Queue of requests waiting for token refresh
+let failedQueue: Array<{
+	resolve: (value?: unknown) => void;
+	reject: (reason?: any) => void;
+}> = [];
+
+const processQueue = (error: any, token: string | null = null) => {
+	failedQueue.forEach(prom => {
+		if (error) {
+			prom.reject(error);
+		} else {
+			prom.resolve(token);
+		}
+	});
+	failedQueue = [];
+};
+
+// Function to refresh the token
+const refreshAccessToken = async (axiosInstance: any): Promise<string | null> => {
+	const refreshToken = dashStorage.getItem('refreshToken');
+	
+	if (!refreshToken) {
+		console.log('[Axios] No refresh token available');
+		return null;
+	}
+
+	try {
+		console.log('[Axios] Attempting to refresh access token...');
+		
+		// Create a new axios instance without interceptors to avoid infinite loops
+		const refreshAxios = axios.create({
+			baseURL: DASHAdminSystemConstants.system.ADMIN_API_URL,
+			headers: {
+				'Content-Type': 'application/json',
+				'Accept': 'application/json',
+			},
+		});
+
+		const response = await refreshAxios.post('/auth/refresh', {
+			refresh_token: refreshToken,
+		});
+
+		if (response.status === 200 && response.data.token) {
+			const newToken = response.data.token;
+			const newRefreshToken = response.data.refresh_token;
+			
+			// Store new tokens
+			dashStorage.setItem('token', newToken);
+			if (newRefreshToken) {
+				dashStorage.setItem('refreshToken', newRefreshToken);
+			}
+			
+			console.log('[Axios] Token refresh successful');
+			return newToken;
+		}
+
+		return null;
+	} catch (error) {
+		console.error('[Axios] Token refresh failed:', error);
+		return null;
+	}
+};
+
+// Function to handle logout
+const handleLogout = () => {
+	console.log('[Axios] Logging out due to authentication failure');
+	debugger;
+	// Clear all auth data
+	//dashStorage.removeItem('token');
+	//dashStorage.removeItem('refreshToken');
+	//dashStorage.removeItem('authenticated');
+	//dashStorage.removeItem('user');
+	//dashStorage.removeItem('roles');
+    dashStorage.clear();
+	localStorage.clear();
+	// Dispatch logout event for the app to handle
+	window.dispatchEvent(new CustomEvent('auth:logout', { 
+		detail: { reason: 'token_refresh_failed' } 
+	}));
+};
+
+export const initAxios = (
+	options: Partial<AxiosRequestConfig<any>>,
+	CSRFAuth?: boolean,
+) => {
+  const browserLanguage = typeof navigator !== 'undefined' && navigator.language ? navigator.language.split('-')[0] : 'es';
+  const _options = {
+    headers: {
+      'Content-Type': 'application/json',
+      //'Accept-Language': browserLanguage || 'es', // fallback to 'es' if not available
+      'Accept-Language':'es',
+      Accept: 'application/json',
+    },
+    ...options,
+  };
+
+	const instance = axios.create(_options);
+
+	if (CSRFAuth) {
+		instance.defaults.withCredentials = true;
+		instance.get('/csrf-cookie').then((response) => {
+			console.log('sanctum', response);
+		});
+	}
+
+	instance.interceptors.request.use(function (config) {
+		const token = dashStorage.getItem('token');
+		//console.log("axios Hook", axios, token);
+		if (token !== undefined && token !== 'undefined') {
+			config.headers.Authorization = 'Bearer ' + token;
+		}
+
+		// Inject X-Tenant-Id header when tenant impersonation is active
+		const activeTenantId = dashStorage.getItem('active_tenant_id');
+		if (activeTenantId) {
+			config.headers['X-Tenant-Id'] = activeTenantId;
+		}
+
+		return config;
+	});
+
+	instance.interceptors.response.use(
+		(response) => {
+			//console.log("Axios Success", response);
+			return response;
+		},
+		async (error: AxiosError<IDashAutoAdminDefaultBackendStructure, any>) => {
+			const originalRequest = error.config as InternalAxiosRequestConfig & { _retry?: boolean };
+
+			// Handle 401 Unauthorized errors
+			if (error.response?.status === 401 && !originalRequest._retry) {
+				// Skip refresh for auth endpoints to prevent infinite loops
+				const isAuthEndpoint = originalRequest.url?.includes('/login') || 
+					originalRequest.url?.includes('/auth/refresh') ||
+					originalRequest.url?.includes('/logout');
+
+				if (isAuthEndpoint) {
+					return Promise.reject(error);
+				}
+
+				if (isRefreshing) {
+					// If already refreshing, queue this request
+					return new Promise((resolve, reject) => {
+						failedQueue.push({ resolve, reject });
+					}).then(token => {
+						if (token && originalRequest.headers) {
+							originalRequest.headers.Authorization = `Bearer ${token}`;
+						}
+						return instance(originalRequest);
+					}).catch(err => {
+						return Promise.reject(err);
+					});
+				}
+
+				originalRequest._retry = true;
+				isRefreshing = true;
+
+				try {
+					const newToken = await refreshAccessToken(instance);
+					
+					if (newToken) {
+						// Update the authorization header
+						if (originalRequest.headers) {
+							originalRequest.headers.Authorization = `Bearer ${newToken}`;
+						}
+						
+						// Process queued requests
+						processQueue(null, newToken);
+						
+						// Retry the original request
+						return instance(originalRequest);
+					} else {
+						// Refresh failed - logout user
+						processQueue(error, null);
+						handleLogout();
+						return Promise.reject(error);
+					}
+				} catch (refreshError) {
+					processQueue(refreshError, null);
+					handleLogout();
+					return Promise.reject(refreshError);
+				} finally {
+					isRefreshing = false;
+				}
+			}
+
+			// Dispatch global error event for non-401 errors
+			window.dispatchEvent(
+				new MessageEvent('DASHGlobalError', {
+					data: processAxiosError(error, null, "list"),
+					origin: "AxiosInterceptor"
+				}),
+			);
+
+			return Promise.reject(error);
+		},
+	);
+
+	return instance;
+};
+
+// Hook version (for use in React components)
+const useAxios = (options?: Partial<AxiosRequestConfig<any>>) => {
+	const a = initAxios({
+		baseURL: DASHAdminSystemConstants.system.ADMIN_API_URL,
+		...(options) && {...options}
+	});
+	return a;
+};
+
+// Non-hook version (for use in classes and regular functions)
+export const createAxiosInstance = (options?: Partial<AxiosRequestConfig<any>>) => {
+	return initAxios({
+		baseURL: DASHAdminSystemConstants.system.ADMIN_API_URL,
+		...(options) && {...options}
+	});
+};
+
+// Default export is the hook
+export default useAxios;
+
+// Named export for non-hook usage
+export { useAxios };

package/src/hooks/useAxiosWithStore.tsx

@@ -0,0 +1,66 @@
+
+import { useEffect, useState } from 'react';
+//import queryString from 'query-string';
+import { useStore } from 'react-admin';
+import useAxios from './useAxios';
+
+export interface IUseAxiosGetWithStore {
+	method?: string;
+	url: string;
+	payload?: any;
+	storeKey: string;
+	dataPath?: string;
+}
+
+const resolveObjectPath = (object, path, defaultValue) =>
+	path.split('.').reduce((o, p) => (o ? o[p] : defaultValue), object);
+
+const useAxiosGetWithStore = (options: IUseAxiosGetWithStore) => {
+	const {
+		/*method = 'GET',
+		url,
+		payload = null,*/
+		storeKey,
+		dataPath = 'data',
+	} = options;
+	const axios = useAxios();
+
+	const [error, setError] = useState(null);
+	const [loaded, setLoaded] = useState(false);
+
+	const [results, setResults] = useStore(storeKey, null);
+
+	const request = async (ops: IUseAxiosGetWithStore) => {
+		//const payload = queryString.stringify(ops.payload, { arrayFormat: 'bracket' });
+
+		try {
+			//console.log('useAxiosGetWithStore performing query:', ops);
+			const response = await axios({
+				method: ops.method,
+				url: `${ops.url}${ops.payload ? '?' + ops.payload : ''}`,
+			});
+
+			if (response.status >= 200 || response.status < 300) {
+				setResults(resolveObjectPath(response, dataPath, null));
+			}
+		} catch (e:any) {
+			setError(e);
+		} finally {
+			setLoaded(true);
+		}
+	};
+
+	useEffect(() => {
+		//console.log('useAxiosGetWithStore results:', results);
+		if (!results) {
+			//console.log('Therefore, performing request');
+			request(options);
+		} else {
+			//console.log('returning stored results');
+		}
+	}, []);
+
+	return { request, results, error, loaded };
+};
+
+export default useAxiosGetWithStore;

package/src/index.tsx

@@ -0,0 +1,4 @@
+export { default as useAxios, createAxiosInstance } from "./hooks/useAxios";
+export { default as useAxiosGetWithStore } from "./hooks/useAxiosWithStore";
+export type { IDashAutoAdminBackendError,IDashAutoAdminDefaultBackendStructure } from "./interfaces/IDashAutoAdminBackendError";
+export { default as processAxiosError } from "./hooks/processAxiosErrorFunction";

package/src/interfaces/IDashAutoAdminBackendError.ts

@@ -0,0 +1,21 @@
+import  { AxiosError } from 'axios';
+
+export interface IDashAutoAdminBackendError {
+  status:        number;
+  body:          Body;
+  resource:      string;
+  originalError: AxiosError<IDashAutoAdminDefaultBackendStructure>;
+  message?:       string;
+}
+
+export interface IDashAutoAdminDefaultBackendStructure {
+  message: string;
+  errors:  {
+    [key: string]: string[];
+  };
+}
+
+interface Body {
+  [x:string]: any
+}
+