anzar 1.0.0 → 1.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anzar",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Anzar SDK",
   "main": "index.ts",
   "keywords": [],

package/src/http/jwt_interceptor.ts

@@ -1,16 +1,43 @@
-import type { AxiosInstance } from "axios";
-import { TokenType } from "../types/token";
+import type {
+  AxiosError,
+  AxiosInstance,
+  InternalAxiosRequestConfig,
+} from "axios";
+import type { AuthResponse } from "../types/auth";
+import { type Token, TokenType } from "../types/token";
+
+const ENDPOINTS = new Map([
+  ["/auth/login", null],
+  ["/auth/register", null],
+  ["/auth/refreshToken", TokenType.RefreshToken],
+  ["/auth/logout", TokenType.RefreshToken],
+]);
+
+const endpointConfig: Record<string, TokenType | null> = {
+  "/auth/login": null,
+  "/auth/register": null,
+  "/auth/refreshToken": TokenType.RefreshToken,
+  "/auth/logout": TokenType.RefreshToken,
+};
 
 export class JwtInterceptor {
-  apply(axios: AxiosInstance) {
-    // your logic
-    axios.interceptors.request.use(
+  // TODO add AnzarConfig as an arg to apply
+  apply(axiosInstance: AxiosInstance) {
+    function _extractTokenFromCache(tokenType: TokenType): Token | null {
+      const token = localStorage.getItem(tokenType.toString());
+
+      return token ? ({ value: token, tokenType } as Token) : null;
+    }
+
+    axiosInstance.interceptors.request.use(
       (config) => {
-        const accessToken = localStorage.getItem(
-          TokenType.AccessToken.toString(),
-        );
-        if (accessToken) {
-          config.headers.Authorization = `Bearer ${accessToken}`;
+        const url = config.url;
+        if (!url) return config;
+        const tokenType = endpointConfig[url] ?? TokenType.AccessToken;
+        const token = tokenType ? _extractTokenFromCache(tokenType) : null;
+
+        if (token) {
+          config.headers.Authorization = `Bearer ${token}`;
         }
 
         return config;
@@ -21,8 +48,85 @@ export class JwtInterceptor {
       },
     );
 
-    axios.interceptors.response.use((response) => {
-      return response;
-    });
+    axiosInstance.interceptors.response.use(
+      (response) => {
+        const url = response.config.url;
+        if (!url) return response;
+
+        if (url === "/auth/logout") {
+          localStorage.removeItem(TokenType.AccessToken.toString());
+          localStorage.removeItem(TokenType.RefreshToken.toString());
+          return response;
+        }
+
+        const value = ENDPOINTS.get(url);
+        const token_type = value === undefined ? TokenType.AccessToken : value;
+
+        if (token_type === TokenType.AccessToken) {
+          return response;
+        }
+
+        const auth_response: AuthResponse = response.data;
+
+        if (auth_response.tokens) {
+          localStorage.setItem(
+            TokenType.AccessToken.toString(),
+            auth_response.tokens.access,
+          );
+          localStorage.setItem(
+            TokenType.RefreshToken.toString(),
+            auth_response.tokens.refresh,
+          );
+        }
+
+        return response;
+      },
+      async (error: AxiosError) => {
+        const originalRequest = error.config as InternalAxiosRequestConfig & {
+          _retry?: boolean;
+        };
+
+        // const value = ENDPOINTS.get(error.request.url);
+        // const token_type = value === undefined ? TokenType.AccessToken : value;
+        // if (error.status === 401 && token_type === TokenType.AccessToken) {
+
+        if (error.response?.status === 401 && !originalRequest._retry) {
+          originalRequest._retry = true;
+
+          try {
+            const refreshToken = localStorage.getItem(
+              TokenType.RefreshToken.toString(),
+            );
+            const response = await axiosInstance.post(
+              "/auth/refreshToken",
+              {},
+              { headers: { authorization: `Bearer ${refreshToken}` } },
+            );
+
+            const auth_response: AuthResponse = response.data;
+            if (auth_response.tokens) {
+              localStorage.setItem(
+                TokenType.AccessToken.toString(),
+                auth_response.tokens.access,
+              );
+              localStorage.setItem(
+                TokenType.RefreshToken.toString(),
+                auth_response.tokens.refresh,
+              );
+            }
+
+            // Retry original request with new token
+            originalRequest.headers.Authorization = `Bearer ${auth_response.tokens?.access}`;
+            return axiosInstance(originalRequest);
+          } catch (e) {
+            localStorage.clear();
+            window.location.href = "/";
+            return Promise.reject(e);
+          }
+        }
+
+        return Promise.reject(error);
+      },
+    );
   }
 }