Login

Author: w3bdesign

src/utils/auth.ts

@@ -1,138 +1,56 @@
 import { ApolloClient, InMemoryCache } from '@apollo/client';
-import { LOGIN_USER, REFRESH_AUTH_TOKEN } from './gql/GQL_MUTATIONS';
-
-let tokenSetter: ReturnType<typeof setInterval>;
+import { LOGIN_USER } from './gql/GQL_MUTATIONS';
 
+// Cookie-based authentication - no token storage needed
 export function hasCredentials() {
   if (typeof window === 'undefined') {
     return false; // Server-side, no credentials available
   }
-
-  const authToken = sessionStorage.getItem(
-    process.env.NEXT_PUBLIC_AUTH_TOKEN_SS_KEY as string
-  );
-  const refreshToken = localStorage.getItem(
-    process.env.NEXT_PUBLIC_REFRESH_TOKEN_LS_KEY as string
-  );
-
-  if (!!authToken && !!refreshToken) {
-    return true;
-  }
-
+  
+  // With cookie-based auth, we'll check if user is logged in through a query
+  // For now, we'll return false and let components handle the check
   return false;
 }
 
 export async function getAuthToken() {
-  let authToken = sessionStorage.getItem(
-    process.env.NEXT_PUBLIC_AUTH_TOKEN_SS_KEY as string,
-  );
-  if (!authToken || !tokenSetter) {
-    authToken = await fetchAuthToken();
-  }
-  return authToken;
-}
-
-async function fetchAuthToken() {
-  const refreshToken = localStorage.getItem(
-    process.env.NEXT_PUBLIC_REFRESH_TOKEN_LS_KEY as string,
-  );
-  if (!refreshToken) {
-    // No refresh token means the user is not authenticated.
-    return;
-  }
-
-  try {
-    const client = new ApolloClient({
-      uri: process.env.NEXT_PUBLIC_GRAPHQL_URL,
-      cache: new InMemoryCache(),
-    });
-
-    const { data } = await client.mutate({
-      mutation: REFRESH_AUTH_TOKEN,
-      variables: { refreshToken },
-    });
-
-    const authToken = data?.refreshJwtAuthToken?.authToken;
-    if (!authToken) {
-      throw new Error('Failed to retrieve a new auth token');
-    }
-    // Save token.
-    sessionStorage.setItem(
-      process.env.NEXT_PUBLIC_AUTH_TOKEN_SS_KEY as string,
-      authToken,
-    );
-    if (tokenSetter) {
-      clearInterval(tokenSetter);
-    }
-    tokenSetter = setInterval(
-      async () => {
-        if (!hasCredentials()) {
-          clearInterval(tokenSetter);
-          return;
-        }
-        fetchAuthToken();
-      },
-      Number(process.env.NEXT_PUBLIC_AUTH_KEY_TIMEOUT || 300000),
-    );
-
-    return authToken;
-  } catch (err) {
-    console.error(err);
-  }
-}
-
-function saveCredentials(
-  authToken: string,
-  sessionToken: string,
-  refreshToken: string | null = null,
-) {
-  sessionStorage.setItem(
-    process.env.NEXT_PUBLIC_AUTH_TOKEN_SS_KEY as string,
-    authToken,
-  );
-  sessionStorage.setItem(
-    process.env.NEXT_PUBLIC_SESSION_TOKEN_LS_KEY as string,
-    sessionToken,
-  );
-  if (refreshToken) {
-    localStorage.setItem(
-      process.env.NEXT_PUBLIC_REFRESH_TOKEN_LS_KEY as string,
-      refreshToken,
-    );
-  }
+  // Cookie-based auth doesn't need JWT tokens
+  return null;
 }
 
 export async function login(username: string, password: string) {
-  const headers: { [key: string]: string } = {};
-  const sessionToken = sessionStorage.getItem(
-    process.env.NEXT_PUBLIC_SESSION_TOKEN_LS_KEY as string,
-  );
-  if (sessionToken) {
-    headers['woocommerce-session'] = `Session ${sessionToken}`;
-  }
   try {
     const client = new ApolloClient({
       uri: process.env.NEXT_PUBLIC_GRAPHQL_URL,
       cache: new InMemoryCache(),
-      headers,
+      credentials: 'include', // Include cookies in requests
     });
 
     const { data } = await client.mutate({
       mutation: LOGIN_USER,
       variables: { username, password },
     });
 
-    const { authToken, refreshToken, customer } = data.login;
+    const loginResult = data.loginWithCookies;
 
-    if (!authToken || !refreshToken || !customer.sessionToken) {
-      throw new Error('Failed to retrieve credentials.');
+    if (loginResult.status !== 'SUCCESS') {
+      throw new Error('Login failed');
     }
-    saveCredentials(authToken, customer.sessionToken, refreshToken);
-    return customer;
+
+    // On successful login, cookies are automatically set by the server
+    return { success: true, status: loginResult.status };
   } catch (error: unknown) {
     if (error instanceof Error) {
       throw new Error(error.message);
     }
     throw new Error('An unknown error occurred during login.');
   }
 }
+
+export async function logout() {
+  // For cookie-based auth, we might need a logout mutation
+  // For now, we can clear any client-side state
+  if (typeof window !== 'undefined') {
+    // Redirect to login or home page after logout
+    window.location.href = '/';
+  }
+}

src/utils/gql/GQL_MUTATIONS.ts

@@ -30,17 +30,9 @@ export const CREATE_USER = gql`
 
 export const LOGIN_USER = gql`
   mutation Login($username: String!, $password: String!) {
-    login(input: { username: $username, password: $password }) {
-      authToken
-      refreshToken
-      customer {
-        id
-        email
-        firstName
-        lastName
-        username
-        sessionToken
-      }
+    loginWithCookies(input: { login: $username, password: $password }) {
+      status
+      clientMutationId
     }
   }
 `;