fix(auth): fix circular import problem by changing the way the authHttpClient gets accessToken; replace individual calls mocks with the common ones

src/features/auth/api/calls/index.ts

@@ -1,3 +1,4 @@
 export * from "./login";
 export * from "./register";
 export * from "./logout";
+export * from "./refresh";

src/features/auth/api/calls/login/constants.ts

@@ -1,6 +0,0 @@
-export const LOGIN_API_ROUTE = "auth/login";
-
-// MOCKS
-export const MOCK_EMAIL = "test@test.com";
-export const MOCK_PASSWORD = "password";
-export const MOCK_TOKEN = "mock.access.token";

src/features/auth/api/calls/login/index.ts

@@ -1,2 +1,2 @@
-export { login } from './login';
-export { LOGIN_API_ROUTE } from './constants';
+export { login } from "./login";
+export { loginMock } from "./login.mock";

src/features/auth/api/calls/login/login.mock.ts

@@ -1,12 +1,8 @@
 import { http, HttpResponse } from "msw";
 import type { AuthData } from "../../../model/types/service";
 import { BASE_URL } from "shared/config";
-import {
-  LOGIN_API_ROUTE,
-  MOCK_EMAIL,
-  MOCK_PASSWORD,
-  MOCK_TOKEN,
-} from "./constants";
+import { LOGIN_API_ROUTE } from "./login";
+import { MOCK_AUTH_RESPONSE, MOCK_EMAIL, MOCK_PASSWORD } from "../mocks";
 
 const LOGIN_URL = `${BASE_URL}/${LOGIN_API_ROUTE}`;
 
@@ -17,10 +13,7 @@ export const loginMock = http.post(LOGIN_URL, async ({ request }) => {
   const { email, password } = (await request.json()) as AuthData;
 
   if (email === MOCK_EMAIL && password === MOCK_PASSWORD) {
-    return HttpResponse.json({
-      accessToken: MOCK_TOKEN,
-      user: { id: "1", email },
-    });
+    return HttpResponse.json(MOCK_AUTH_RESPONSE);
   }
 
   return HttpResponse.json({ message: "Invalid credentials" }, { status: 401 });

src/features/auth/api/calls/login/login.spec.ts

@@ -1,7 +1,12 @@
 import { setupServer } from "msw/node";
 import { login } from "./login";
 import { loginMock } from "./login.mock";
-import { MOCK_EMAIL, MOCK_PASSWORD } from "./constants";
+import {
+  MOCK_EMAIL,
+  MOCK_EXISTING_USER,
+  MOCK_PASSWORD,
+  MOCK_TOKEN,
+} from "../mocks";
 
 const server = setupServer(loginMock);
 
@@ -12,10 +17,13 @@ describe("login", () => {
 
   describe("happy path", () => {
     it("returns access token and user on valid credentials", async () => {
-      const result = await login({ email: MOCK_EMAIL, password: MOCK_PASSWORD });
+      const result = await login({
+        email: MOCK_EMAIL,
+        password: MOCK_PASSWORD,
+      });
 
-      expect(result.accessToken).toBe("mock.access.token");
-      expect(result.user).toEqual({ id: "1", email: MOCK_EMAIL });
+      expect(result.accessToken).toBe(MOCK_TOKEN);
+      expect(result.user).toEqual(MOCK_EXISTING_USER);
     });
   });
 

src/features/auth/api/calls/login/login.ts

@@ -1,6 +1,7 @@
-import { api } from "../../../api";
 import type { AuthData, AuthResponse } from "../../../model/types/service";
-import { LOGIN_API_ROUTE } from "./constants";
+import { authHttpClient } from "../../config/authApi/authApi";
+
+export const LOGIN_API_ROUTE = "auth/login";
 
 /**
  * Logs in a user with the given email and password.
@@ -9,5 +10,7 @@ import { LOGIN_API_ROUTE } from "./constants";
  * @returns A promise that resolves to the authentication response.
  */
 export function login(loginData: AuthData) {
-  return api.post(LOGIN_API_ROUTE, { json: loginData }).json<AuthResponse>();
+  return authHttpClient
+    .post(LOGIN_API_ROUTE, { json: loginData })
+    .json<AuthResponse>();
 }

src/features/auth/api/calls/logout/constants.ts

@@ -1 +0,0 @@
-export const LOGOUT_API_ROUTE = "auth/logout";

src/features/auth/api/calls/logout/index.ts

@@ -1,2 +1,2 @@
 export { logout } from "./logout";
-export { LOGOUT_API_ROUTE } from "./constants";
+export { logoutMock } from "./logout.mock";

src/features/auth/api/calls/logout/logout.mock.ts

@@ -1,6 +1,6 @@
 import { http, HttpResponse } from "msw";
 import { BASE_URL } from "shared/config";
-import { LOGOUT_API_ROUTE } from "./constants";
+import { LOGOUT_API_ROUTE } from "./logout";
 
 const LOGOUT_URL = `${BASE_URL}/${LOGOUT_API_ROUTE}`;
 

src/features/auth/api/calls/logout/logout.ts

@@ -1,5 +1,6 @@
-import { api } from "../../../api";
-import { LOGOUT_API_ROUTE } from "./constants";
+import { authHttpClient } from "../../config";
+
+export const LOGOUT_API_ROUTE = "auth/logout";
 
 /**
  * Logs out the currently authenticated user.
@@ -8,5 +9,5 @@ import { LOGOUT_API_ROUTE } from "./constants";
  * @returns A promise that resolves when the session is terminated.
  */
 export async function logout(): Promise<void> {
-  await api.post(LOGOUT_API_ROUTE);
+  await authHttpClient.post(LOGOUT_API_ROUTE);
 }

src/features/auth/api/calls/mocks.ts

@@ -0,0 +1,23 @@
+import type { User } from "entities/User";
+import type { AuthResponse } from "../../model";
+
+export const MOCK_TOKEN = "mock.access.token";
+export const MOCK_FRESH_TOKEN = "mock.fresh.access.token";
+export const MOCK_EMAIL = "test@test.com";
+export const MOCK_NEW_EMAIL = "new@test.com";
+export const MOCK_PASSWORD = "password";
+
+export const MOCK_EXISTING_USER: User = {
+  id: "1",
+  email: MOCK_EMAIL,
+};
+
+export const MOCK_NEW_USER: User = {
+  id: "2",
+  email: MOCK_NEW_EMAIL,
+};
+
+export const MOCK_AUTH_RESPONSE: AuthResponse = {
+  accessToken: MOCK_TOKEN,
+  user: MOCK_EXISTING_USER,
+};

src/features/auth/api/calls/refresh/index.ts

@@ -0,0 +1,2 @@
+export { refresh } from "./refresh";
+export { refreshMock } from "./refresh.mock";

src/features/auth/api/calls/refresh/refresh.mock.ts

@@ -0,0 +1,23 @@
+import { http, HttpResponse } from "msw";
+import { BASE_URL } from "shared/config";
+import { REFRESH_API_ROUTE } from "./refresh";
+import { MOCK_EXISTING_USER, MOCK_FRESH_TOKEN, MOCK_TOKEN } from "../mocks";
+
+const REFRESH_URL = `${BASE_URL}/${REFRESH_API_ROUTE}`;
+
+/**
+ * Msw interceptor. Mocks the refresh endpoint response.
+ * Validates the Authorization header — returns a fresh token on success, 401 on expired/missing session.
+ */
+export const refreshMock = http.post(REFRESH_URL, ({ request }) => {
+  const authHeader = request.headers.get("Authorization");
+
+  if (authHeader === `Bearer ${MOCK_TOKEN}`) {
+    return HttpResponse.json({
+      user: MOCK_EXISTING_USER,
+      accessToken: MOCK_FRESH_TOKEN,
+    });
+  }
+
+  return HttpResponse.json({ message: "Session expired" }, { status: 401 });
+});

src/features/auth/api/calls/refresh/refresh.spec.ts

@@ -0,0 +1,33 @@
+import { setupServer } from "msw/node";
+import { useAuthStore } from "../../../model";
+import { refresh } from "./refresh";
+import { refreshMock } from "./refresh.mock";
+import { MOCK_EXISTING_USER, MOCK_FRESH_TOKEN, MOCK_TOKEN } from "../mocks";
+
+const server = setupServer(refreshMock);
+
+describe("refresh", () => {
+  beforeAll(() => server.listen({ onUnhandledRequest: "error" }));
+  afterEach(() => {
+    server.resetHandlers();
+    useAuthStore.setState({ accessToken: undefined });
+  });
+  afterAll(() => server.close());
+
+  describe("happy path", () => {
+    it("returns a fresh access token and user when session is valid", async () => {
+      useAuthStore.setState({ accessToken: MOCK_TOKEN });
+
+      const result = await refresh();
+
+      expect(result.accessToken).toBe(MOCK_FRESH_TOKEN);
+      expect(result.user).toEqual(MOCK_EXISTING_USER);
+    });
+  });
+
+  describe("error cases", () => {
+    it("throws when session is expired or missing", async () => {
+      await expect(refresh()).rejects.toThrow();
+    });
+  });
+});

src/features/auth/api/calls/refresh/refresh.ts

@@ -0,0 +1,8 @@
+import type { AuthResponse } from "../../../model/types/service";
+import { authHttpClient } from "../../config/authApi/authApi";
+
+export const REFRESH_API_ROUTE = "auth/refresh";
+
+export function refresh() {
+  return authHttpClient.post(REFRESH_API_ROUTE).json<AuthResponse>();
+}

src/features/auth/api/calls/register/constants.ts

@@ -1,6 +0,0 @@
-export const REGISTER_API_ROUTE = "auth/register";
-
-// MOCKS
-export const MOCK_EMAIL = "test@test.com";
-export const MOCK_PASSWORD = "password";
-export const MOCK_TOKEN = "mock.access.token";

src/features/auth/api/calls/register/index.ts

@@ -1,2 +1,2 @@
 export { register } from "./register";
-export { REGISTER_API_ROUTE } from "./constants";
+export { registerMock } from "./register.mock";

src/features/auth/api/calls/register/register.mock.ts

@@ -1,7 +1,8 @@
 import { http, HttpResponse } from "msw";
 import type { AuthData } from "../../../model/types/service";
 import { BASE_URL } from "shared/config";
-import { REGISTER_API_ROUTE, MOCK_EMAIL, MOCK_TOKEN } from "./constants";
+import { REGISTER_API_ROUTE } from "./register";
+import { MOCK_EMAIL, MOCK_TOKEN } from "../mocks";
 
 const REGISTER_URL = `${BASE_URL}/${REGISTER_API_ROUTE}`;
 

src/features/auth/api/calls/register/register.spec.ts

@@ -1,7 +1,13 @@
 import { setupServer } from "msw/node";
 import { register } from "./register";
 import { registerMock } from "./register.mock";
-import { MOCK_EMAIL, MOCK_PASSWORD, MOCK_TOKEN } from "./constants";
+import {
+  MOCK_EMAIL,
+  MOCK_NEW_EMAIL,
+  MOCK_NEW_USER,
+  MOCK_PASSWORD,
+  MOCK_TOKEN,
+} from "../mocks";
 
 const server = setupServer(registerMock);
 
@@ -12,10 +18,13 @@ describe("register", () => {
 
   describe("happy path", () => {
     it("returns access token and user for a new email", async () => {
-      const result = await register({ email: "new@test.com", password: MOCK_PASSWORD });
+      const result = await register({
+        email: MOCK_NEW_EMAIL,
+        password: MOCK_PASSWORD,
+      });
 
       expect(result.accessToken).toBe(MOCK_TOKEN);
-      expect(result.user).toEqual({ id: "2", email: "new@test.com" });
+      expect(result.user).toEqual(MOCK_NEW_USER);
     });
   });
 

src/features/auth/api/calls/register/register.ts

@@ -1,6 +1,7 @@
-import { api } from "../../../api";
 import type { AuthData, AuthResponse } from "../../../model/types/service";
-import { REGISTER_API_ROUTE } from "./constants";
+import { authHttpClient } from "../../config/authApi/authApi";
+
+export const REGISTER_API_ROUTE = "auth/register";
 
 /**
  * Registers a new user with the given email and password.
@@ -9,5 +10,7 @@ import { REGISTER_API_ROUTE } from "./constants";
  * @returns A promise that resolves to the authentication response.
  */
 export function register(registerData: AuthData) {
-  return api.post(REGISTER_API_ROUTE, { json: registerData }).json<AuthResponse>();
+  return authHttpClient
+    .post(REGISTER_API_ROUTE, { json: registerData })
+    .json<AuthResponse>();
 }

src/features/auth/api/config/authApi/authApi.ts

@@ -1,19 +1,44 @@
 import { api as baseApi } from "shared/config";
 
-// Extend base API with authentication hooks
-export const api = baseApi.extend({
-  hooks: {
-    beforeRequest: [
-      (request) => {
-        // Add authentication token to request headers
-        return request;
-      },
-    ],
-    afterResponse: [
-      async (request, options, response) => {
-        // Refresh token logic
-        return response;
-      },
-    ],
-  },
-});
+type TokenGetter = () => string | null | undefined;
+
+class HttpClient {
+  private getToken: TokenGetter = () => null;
+
+  setTokenGetter(fn: TokenGetter) {
+    this.getToken = fn;
+  }
+
+  // Extend base API with authentication hooks
+  private instance = baseApi.extend({
+    hooks: {
+      beforeRequest: [
+        (request) => {
+          const token = this.getToken();
+
+          if (token) {
+            request.headers.set("Authorization", `Bearer ${token}`);
+          }
+
+          return request;
+        },
+      ],
+      afterResponse: [
+        async (request, options, response) => {
+          // Refresh token logic
+          return response;
+        },
+      ],
+    },
+  });
+
+  get = (url: string, options?: Parameters<typeof this.instance.get>[1]) => {
+    return this.instance.get(url, options);
+  };
+
+  post = (url: string, options?: Parameters<typeof this.instance.post>[1]) => {
+    return this.instance.post(url, options);
+  };
+}
+
+export const authHttpClient = new HttpClient();

src/features/auth/api/config/index.ts

@@ -1 +1 @@
-export * from "./authApi/authApi";
+export { authHttpClient } from "./authApi/authApi";

src/features/auth/model/stores/authStore/authStore.ts

@@ -1,14 +1,20 @@
 import { create } from "zustand";
-import type { AuthStore } from "../../types/store";
-import { login, logout, register } from "../../../api";
+import type { AuthStore, AuthStoreState } from "../../types/store";
+import { login, logout, refresh, register } from "../../../api";
 import { callApi } from "shared/utils";
 import { UNEXPECTED_ERROR_MESSAGE } from "shared/config";
+import { authHttpClient } from "../../../api/config/authApi/authApi";
 
-export const useAuthStore = create<AuthStore>()((set) => ({
+export const defaultStoreState: Readonly<AuthStoreState> = {
   user: undefined,
   status: "idle",
+  accessToken: undefined,
   error: null,
+};
 
+export const useAuthStore = create<AuthStore>()((set) => ({
+  ...defaultStoreState,
+  reset: () => set({ ...defaultStoreState }),
   login: async (loginData) => {
     set({ status: "loading" });
     try {
@@ -22,6 +28,7 @@ export const useAuthStore = create<AuthStore>()((set) => ({
       set({
         status: "authenticated",
         user: responseData?.user,
+        accessToken: responseData?.accessToken,
         error: null,
       });
     } catch (err) {
@@ -46,6 +53,7 @@ export const useAuthStore = create<AuthStore>()((set) => ({
       set({
         status: "authenticated",
         user: responseData?.user,
+        accessToken: responseData?.accessToken,
         error: null,
       });
     } catch (err) {
@@ -76,4 +84,30 @@ export const useAuthStore = create<AuthStore>()((set) => ({
       set({ error: new Error(UNEXPECTED_ERROR_MESSAGE) });
     }
   },
+  refresh: async () => {
+    set({ status: "loading" });
+    try {
+      const [responseData, refreshError] = await callApi(() => refresh());
+
+      if (refreshError) {
+        set({ status: "unauthenticated", error: refreshError });
+        return;
+      }
+
+      set({
+        status: "authenticated",
+        user: responseData?.user,
+        accessToken: responseData?.accessToken,
+        error: null,
+      });
+    } catch (err) {
+      console.error(err);
+      set({
+        status: "unauthenticated",
+        error: new Error(UNEXPECTED_ERROR_MESSAGE),
+      });
+    }
+  },
 }));
+
+authHttpClient.setTokenGetter(() => useAuthStore.getState().accessToken);

src/features/auth/model/types/store.ts

@@ -11,21 +11,28 @@ export interface AuthStoreState {
    * Authentication status
    */
   status: AuthStatus;
+  /**
+   * Authentication token
+   */
+  accessToken?: string;
   /**
    * Error data
    */
   error: ApiError | Error | null;
 }
 
-export type LoginAction = (data: AuthData) => void;
-export type RegisterAction = (data: AuthData) => void;
-export type LogoutAction = () => void;
+export type ResetAction = () => void;
+export type LoginAction = (data: AuthData) => Promise<void>;
+export type RegisterAction = (data: AuthData) => Promise<void>;
+export type LogoutAction = () => Promise<void>;
+export type RefreshAction = () => Promise<void>;
 
 export interface AuthStoreActions {
-  // Async actions
+  reset: ResetAction;
   login: LoginAction;
   register: RegisterAction;
   logout: LogoutAction;
+  refresh: RefreshAction;
 }
 
 export type AuthStore = AuthStoreState & AuthStoreActions;