Cambios en refresh token para no dar error. No actualiza access token de la cookie/session. Elimina access token de la cookie para forzar cerrar la session en caso de error

apps/web/lib/auth-token.ts

@@ -6,7 +6,12 @@ import { cache } from 'react';
 export const getValidAccessToken = cache(async () => {
   const session = await auth();
 
-  if (!session?.access_token) return null;
+  if (!session?.access_token) {
+    // console.log('No hay Access Token');
+    return null
+  }
+  // console.log('Si hay Access Token');
+
 
   const now = Math.floor(Date.now() / 1000);
   // Restamos 10s para tener margen de seguridad
@@ -14,24 +19,35 @@ export const getValidAccessToken = cache(async () => {
 
   // A. Si es válido, lo retornamos directo
   if (isValid) return session.access_token;
+  // console.log('Access Token Expiró');
+
 
   // B. Si expiró, buscamos la cookie
   const cookieStore = cookies();
-  const refreshToken = (await cookieStore).get('refresh_token')?.value;
+  const refreshTokenCookie = await cookieStore
+  const refreshToken = refreshTokenCookie.get('refresh_token')?.value;
+
+  if (!refreshToken) {
+    // console.log('No hay Refresh Token');
+    return null
+  } // No hay refresh token, fin del juego
+  // console.log('Si hay Refresh Token');
 
-  if (!refreshToken) return null; // No hay refresh token, fin del juego
 
   // C. Intentamos refrescar
-  const newTokens = await resfreshTokenAction({ token: refreshToken });
+  const newTokens = await resfreshTokenAction({ refreshToken });
 
   if (!newTokens) {
+    // console.log('No hay token nuevo');
     // Si falla el refresh (token revocado o expirado), borramos cookie
     (await cookieStore).delete('refresh_token');
+    (await cookieStore).delete('authjs.session-token');
     return null;
   }
+  // console.log('Si hay token nuevo');
 
   // D. Guardamos el nuevo refresh token en cookie y retornamos el access token
-  (await cookieStore).set('refresh_token', newTokens.tokens.refresh_token, {
+  (await cookieStore).set('refresh_token', newTokens.refresh_token, {
     httpOnly: true,
     secure: process.env.NODE_ENV === 'production',
     sameSite: 'lax',
@@ -39,5 +55,13 @@ export const getValidAccessToken = cache(async () => {
     maxAge: 7 * 24 * 60 * 60,
   });
 
-  return newTokens.tokens.access_token;
+  // (await cookieStore).set('authjs.session-token', newTokens.access_token, {
+  //   httpOnly: true,
+  //   secure: process.env.NODE_ENV === 'production',
+  //   sameSite: 'lax',
+  //   path: '/',
+  //   maxAge: 7 * 24 * 60 * 60,
+  // });
+
+  return newTokens.access_token;
 });

apps/web/lib/fetch.api2.ts

@@ -1,98 +0,0 @@
-'use server';
-import { env } from '@/lib/env'; // Importamos la configuración de entorno validada
-import axios, { InternalAxiosRequestConfig } from 'axios';
-import { z } from 'zod';
-
-// Crear instancia de Axios con la URL base validada
-const fetchApi = axios.create({
-  baseURL: env.API_URL, // Aquí usamos env.API_URL en vez de process.env.BACKEND_URL
-  headers: {
-    'Content-Type': 'application/json',
-  },
-});
-
-// Interceptor para incluir el token automáticamente en las peticiones
-fetchApi.interceptors.request.use(
-  async (config: InternalAxiosRequestConfig) => {
-    try {
-      const { getValidAccessToken } = await import('@/lib/auth-token');
-      const token = await getValidAccessToken();
-
-      if (token) {
-        config.headers.set('Authorization', `Bearer ${token}`);
-      }
-    } catch (err) {
-      console.error('Error getting auth token:', err);
-    }
-    return config;
-  },
-);
-
-/**
- * Función para hacer peticiones con validación de respuesta
- * @param schema - Esquema de Zod para validar la respuesta
- * @param url - Endpoint a consultar
- * @param config - Configuración opcional de Axios
- * @returns [error, data] -> Devuelve el error como objeto estructurado si hay fallo, o los datos validados
- */
-export const safeFetchApi = async <T extends z.ZodSchema<any>>(
-  schema: T,
-  url: string,
-  method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' = 'GET',
-  body?: any,
-): Promise<
-  [{ type: string; message: string; details?: any } | null, z.infer<T> | null]
-> => {
-  try {
-    const response = await fetchApi({
-      method,
-      url,
-      data: body,
-    });
-
-    const parsed = schema.safeParse(response.data);
-
-    if (!parsed.success) {
-      console.error('Validation Error Details:', {
-        errors: parsed.error.errors,
-        receivedData: response.data,
-        expectedSchema: schema,
-        data: response.data.data,
-      });
-      // console.error(parsed.error.errors)
-      return [
-        {
-          type: 'VALIDATION_ERROR',
-          message: 'Validation error',
-          details: parsed.error.errors,
-        },
-        null,
-      ];
-    }
-
-    return [null, parsed.data];
-  } catch (error: any) {
-    const errorDetails = {
-      status: error.response?.status,
-      statusText: error.response?.statusText,
-      message: error.message,
-      url: error.config?.url,
-      method: error.config?.method,
-      requestData: error.config?.data,
-      responseData: error.response?.data,
-      headers: error.config?.headers,
-    };
-
-    // console.log(error)
-    return [
-      {
-        type: 'API_ERROR',
-        message: error.response?.data?.message || 'Unknown API error',
-        details: errorDetails,
-      },
-      null,
-    ];
-  }
-};
-
-export { fetchApi };