@vitalfit/sdk 0.2.6 → 0.2.8

package/dist/index.cjs

@@ -62,7 +62,15 @@ var isAPIError = (error) => {
 // src/client.ts
 var Client = class {
   client;
-  jwt;
+  isRefreshing = false;
+  failedQueue = [];
+  // Guardamos los tokens internamente en el cliente
+  accessToken;
+  refreshToken;
+  // Callback para notificar al frontend (AuthProvider) que los tokens cambiaron
+  onTokenUpdate;
+  // Callback para forzar logout si el refresh falla
+  onLogout;
   constructor(isDevMode, origin) {
     let headers = {
       "Content-Type": "application/json"
@@ -74,24 +82,89 @@ var Client = class {
       baseURL: isDevMode ? DEV_URL : BASE_URL,
       headers
     });
+    this.setupInterceptors();
   }
-  async call(method, config) {
-    if (config.jwt) {
-      this.client.interceptors.request.use((axiosConfig) => {
-        if (axiosConfig.headers) {
-          axiosConfig.headers["Authorization"] = `Bearer ${config.jwt}`;
+  // Configurar callbacks desde el AuthProvider
+  setCallbacks(onTokenUpdate, onLogout) {
+    this.onTokenUpdate = onTokenUpdate;
+    this.onLogout = onLogout;
+  }
+  setTokens(access, refresh) {
+    this.accessToken = access;
+    this.refreshToken = refresh;
+  }
+  removeTokens() {
+    this.accessToken = void 0;
+    this.refreshToken = void 0;
+  }
+  processQueue(error, token = null) {
+    this.failedQueue.forEach((prom) => {
+      if (error) {
+        prom.reject(error);
+      } else {
+        prom.resolve(token);
+      }
+    });
+    this.failedQueue = [];
+  }
+  setupInterceptors() {
+    this.client.interceptors.response.use(
+      (response) => response,
+      async (error) => {
+        const originalRequest = error.config;
+        if (error.response?.status === 401 && !originalRequest._retry) {
+          if (!this.refreshToken) {
+            return Promise.reject(error);
+          }
+          if (this.isRefreshing) {
+            return new Promise((resolve, reject) => {
+              this.failedQueue.push({ resolve, reject });
+            }).then((token) => {
+              originalRequest.headers["Authorization"] = `Bearer ${token}`;
+              return this.client(originalRequest);
+            }).catch((err) => Promise.reject(err));
+          }
+          originalRequest._retry = true;
+          this.isRefreshing = true;
+          try {
+            const response = await import_axios.default.post(`${this.client.defaults.baseURL}/auth/refresh`, {
+              refresh_token: this.refreshToken
+            });
+            const { access_token, refresh_token } = response.data;
+            this.setTokens(access_token, refresh_token);
+            if (this.onTokenUpdate) {
+              this.onTokenUpdate(access_token, refresh_token);
+            }
+            this.processQueue(null, access_token);
+            originalRequest.headers["Authorization"] = `Bearer ${access_token}`;
+            return this.client(originalRequest);
+          } catch (refreshError) {
+            this.processQueue(refreshError, null);
+            this.removeTokens();
+            if (this.onLogout) this.onLogout();
+            return Promise.reject(refreshError);
+          } finally {
+            this.isRefreshing = false;
+          }
         }
-        return axiosConfig;
-      });
+        return Promise.reject(error);
+      }
+    );
+  }
+  async call(method, config) {
+    const tokenToUse = this.accessToken || config.jwt;
+    const axiosConfig = {
+      method,
+      url: config.url,
+      data: config.data,
+      params: config.params,
+      headers: {}
+    };
+    if (tokenToUse && axiosConfig.headers) {
+      axiosConfig.headers["Authorization"] = `Bearer ${tokenToUse}`;
     }
     try {
-      const response = await this.client.request({
-        method,
-        url: config.url,
-        data: config.data,
-        params: config.params
-      });
-      this.client.interceptors.request.clear();
+      const response = await this.client.request(axiosConfig);
       return response.data;
     } catch (error) {
       if (import_axios.default.isAxiosError(error)) {
@@ -128,26 +201,16 @@ var Client = class {
     }
   }
   async post(config) {
-    const data = await this.call("post", config);
-    return data;
+    return this.call("post", config);
   }
   async put(config) {
-    const data = await this.call("put", config);
-    return data;
+    return this.call("put", config);
   }
   async patch(config) {
-    const data = await this.call("patch", config);
-    return data;
+    return this.call("patch", config);
   }
   async delete(config) {
-    const data = await this.call("delete", config);
-    return data;
-  }
-  setJWT(jwt) {
-    this.jwt = jwt;
-  }
-  removeJWT() {
-    this.jwt = void 0;
+    return this.call("delete", config);
   }
 };
 
@@ -167,6 +230,61 @@ var AuthService = class {
     this.oAuthLogin = this.oAuthLogin.bind(this);
     this.logout = this.logout.bind(this);
     this.saveJWT = this.saveJWT.bind(this);
+    this.saveTokens = this.saveTokens.bind(this);
+    this.renewToken = this.renewToken.bind(this);
+    this.revokeAllSessions = this.revokeAllSessions.bind(this);
+    this.revokeAllSessionsByUserID = this.revokeAllSessionsByUserID.bind(this);
+    this.revokeSession = this.revokeSession.bind(this);
+    this.revokeSessionByID = this.revokeSessionByID.bind(this);
+    this.getUserSessions = this.getUserSessions.bind(this);
+    this.getUserSessionByID = this.getUserSessionByID.bind(this);
+  }
+  async renewToken(refresh_token) {
+    const response = await this.client.post({
+      url: "/auth/refresh",
+      data: {
+        refresh_token
+      }
+    });
+    return response;
+  }
+  async revokeAllSessions(jwt) {
+    await this.client.delete({
+      url: "/user/sessions",
+      jwt
+    });
+  }
+  async revokeAllSessionsByUserID(userId, jwt) {
+    await this.client.delete({
+      url: `/user/${userId}/sessions`,
+      jwt
+    });
+  }
+  async revokeSession(sessionId, jwt) {
+    await this.client.delete({
+      url: `/user/sessions/${sessionId}`,
+      jwt
+    });
+  }
+  async revokeSessionByID(sessionId, jwt) {
+    await this.client.delete({
+      url: `/user/sessions/${sessionId}`,
+      jwt
+    });
+  }
+  async getUserSessions(jwt) {
+    const response = await this.client.get({
+      url: "/user/sessions",
+      jwt
+    });
+    return response;
+  }
+  async getUserSessionByID(userId, jwt) {
+    const response = await this.client.get({
+      url: `/user/${userId}/sessions`,
+      jwt
+    });
+    return response;
   }
   async login({
     email,
@@ -184,10 +302,13 @@ var AuthService = class {
     return response;
   }
   logout() {
-    this.client.removeJWT();
+    this.client.removeTokens();
   }
   saveJWT(jwt) {
-    this.client.setJWT(jwt);
+    this.client.setTokens(jwt, "");
+  }
+  saveTokens(access, refresh) {
+    this.client.setTokens(access, refresh);
   }
   async signUp(signUpData) {
     const birthDateRegex = /^\d{4}-\d{2}-\d{2}$/;
@@ -2248,7 +2369,7 @@ var VitalFit = class _VitalFit {
     return _VitalFit.instance;
   }
   version() {
-    return "0.2.6";
+    return "0.2.8";
   }
 };
 // Annotate the CommonJS export names for ESM import in node: