middleware redirecting to authentification login but user is connected and cookie token is logged

export default defineNuxtRouteMiddleware(async (to, from) => {
  // Only run on client-side
  if (import.meta.client) {
    const authCookie = useCookie('auth_token');

    if (!authCookie.value) {
      console.log('redirecting to login');
      return navigateTo('/dashboard/auth/login');
    } else {
      console.log('cookie found! not redirecting');
    }
  }
});

export default defineNuxtRouteMiddleware(async (to, from) => {
  // Only run on client-side
  if (import.meta.client) {
    const authCookie = useCookie('auth_token');

    if (!authCookie.value) {
      console.log('redirecting to login');
      return navigateTo('/dashboard/auth/login');
    } else {
      console.log('cookie found! not redirecting');
    }
  }
});

export default defineNuxtRouteMiddleware(async (to, from) => {
  const nuxt = useNuxtApp();
  const authCookie = nuxt.$cookies.get('auth_token');

  if (!authCookie) {
    console.log('redirecting to login');
    return navigateTo('/dashboard/auth/login');
  } else {
    console.log('cookie found! not redirecting');
  }
});

export default defineNuxtRouteMiddleware(async (to, from) => {
  const nuxt = useNuxtApp();
  const authCookie = nuxt.$cookies.get('auth_token');

  if (!authCookie) {
    console.log('redirecting to login');
    return navigateTo('/dashboard/auth/login');
  } else {
    console.log('cookie found! not redirecting');
  }
});

export default defineNuxtRouteMiddleware((to, from) => {
  // Only run on client-side
  if (process.client) {
    const authCookie = useCookie('auth_token');

    if (!authCookie.value) {
      console.log('redirecting to login');
      return navigateTo('/dashboard/auth/login');
    } else {
      console.log('cookie found! not redirecting');
    }
  }
});

export default defineNuxtRouteMiddleware((to, from) => {
  // Only run on client-side
  if (process.client) {
    const authCookie = useCookie('auth_token');

    if (!authCookie.value) {
      console.log('redirecting to login');
      return navigateTo('/dashboard/auth/login');
    } else {
      console.log('cookie found! not redirecting');
    }
  }
});

   const headers = useRequestHeaders(['cookie'])
   const { data } = await useFetch('/api/me', { headers })
   

   const headers = useRequestHeaders(['cookie'])
   const { data } = await useFetch('/api/me', { headers })
   

   export default defineNuxtRouteMiddleware((to, from) => {
     if (process.server) {
       // Server-side logic
       const headers = useRequestHeaders(['cookie'])
       // Check for authentication using headers
     } else {
       // Client-side logic
       const authCookie = useCookie('auth_token')
       if (!authCookie.value) {
         console.log('redirecting to login')
         return navigateTo('/dashboard/auth/login')
       } else {
         console.log('cookie found! not redirecting')
       }
     }
   })
   

   export default defineNuxtRouteMiddleware((to, from) => {
     if (process.server) {
       // Server-side logic
       const headers = useRequestHeaders(['cookie'])
       // Check for authentication using headers
     } else {
       // Client-side logic
       const authCookie = useCookie('auth_token')
       if (!authCookie.value) {
         console.log('redirecting to login')
         return navigateTo('/dashboard/auth/login')
       } else {
         console.log('cookie found! not redirecting')
       }
     }
   })
   

   if (to.name == 'your-protected-route' && to.path !== from.path) {
     if (from.path !== to.path) {
       return
     }
     return navigateTo(to.path, { replace: false })
   }
   

   if (to.name == 'your-protected-route' && to.path !== from.path) {
     if (from.path !== to.path) {
       return
     }
     return navigateTo(to.path, { replace: false })
   }
   

   const tokenCookie = useCookie('auth_token')

   // After setting the cookie
   refreshCookie('auth_token')
   

   const tokenCookie = useCookie('auth_token')

   // After setting the cookie
   refreshCookie('auth_token')
   

   // nuxt.config.ts
   export default defineNuxtConfig({
     experimental: {
       cookieStore: true
     }
   })
   

   // nuxt.config.ts
   export default defineNuxtConfig({
     experimental: {
       cookieStore: true
     }
   })
   

   const event = useRequestEvent()
const res = await $fetch<{ accessToken: string }>('/api/auth/refresh', {
     method: 'POST',
     headers: useRequestHeaders(['cookie']),
     onResponse({ response }) {
       const cookies = response.headers.getSetCookie()
       if (cookies.length && event) {
         cookies.forEach((cookie) => {
           appendResponseHeader(event, 'set-cookie', cookie)
         })
       }
     },
   })
   

   const event = useRequestEvent()
const res = await $fetch<{ accessToken: string }>('/api/auth/refresh', {
     method: 'POST',
     headers: useRequestHeaders(['cookie']),
     onResponse({ response }) {
       const cookies = response.headers.getSetCookie()
       if (cookies.length && event) {
         cookies.forEach((cookie) => {
           appendResponseHeader(event, 'set-cookie', cookie)
         })
       }
     },
   })
   

   const nuxtApp = useNuxtApp()
   nuxtApp.runWithContext(() => {
     // Your code using composables here
   })
   

   const nuxtApp = useNuxtApp()
   nuxtApp.runWithContext(() => {
     // Your code using composables here
   })
   

import { useCookie, useRequestEvent, useNuxtApp } from '#app';

export default defineNuxtRouteMiddleware((to, from) => {
  const nuxtApp = useNuxtApp();

  return nuxtApp.runWithContext(() => {
    const authCookie = useCookie('auth_token');
    const event = useRequestEvent();

    if (process.server) {
      // Server-side logic
      const headers = useRequestHeaders(['cookie']);
      const serverCookie = headers.cookie;
      console.log('Server-side cookie:', serverCookie);

      if (!serverCookie || !serverCookie.includes('auth_token=')) {
        console.log('Server: redirecting to login');
        return navigateTo('/dashboard/auth/login');
      }
    } else {
      // Client-side logic
      console.log('Client-side cookie:', authCookie.value);

      if (!authCookie.value) {
        console.log('Client: redirecting to login');
        return navigateTo('/dashboard/auth/login');
      }
    }

    // If we reach here, the user is authenticated
    console.log('User authenticated, proceeding to route');
    
    // Refresh the cookie value to ensure it's up-to-date
    if (process.client) {
      refreshCookie('auth_token');
    }
  });
});

import { useCookie, useRequestEvent, useNuxtApp } from '#app';

export default defineNuxtRouteMiddleware((to, from) => {
  const nuxtApp = useNuxtApp();

  return nuxtApp.runWithContext(() => {
    const authCookie = useCookie('auth_token');
    const event = useRequestEvent();

    if (process.server) {
      // Server-side logic
      const headers = useRequestHeaders(['cookie']);
      const serverCookie = headers.cookie;
      console.log('Server-side cookie:', serverCookie);

      if (!serverCookie || !serverCookie.includes('auth_token=')) {
        console.log('Server: redirecting to login');
        return navigateTo('/dashboard/auth/login');
      }
    } else {
      // Client-side logic
      console.log('Client-side cookie:', authCookie.value);

      if (!authCookie.value) {
        console.log('Client: redirecting to login');
        return navigateTo('/dashboard/auth/login');
      }
    }

    // If we reach here, the user is authenticated
    console.log('User authenticated, proceeding to route');
    
    // Refresh the cookie value to ensure it's up-to-date
    if (process.client) {
      refreshCookie('auth_token');
    }
  });
});

export default defineNuxtConfig({
  experimental: {
    cookieStore: true
  }
})

export default defineNuxtConfig({
  experimental: {
    cookieStore: true
  }
})

// composables/useCookieProxy.ts
import { appendResponseHeader } from 'h3'
import type { H3Event } from 'h3'

export const useCookieProxy = async (event: H3Event, url: string) => {
  const res = await $fetch.raw(url)
  const cookies = res.headers.getSetCookie()
  for (const cookie of cookies) {
    appendResponseHeader(event, 'set-cookie', cookie)
  }
  return res._data
}

// composables/useCookieProxy.ts
import { appendResponseHeader } from 'h3'
import type { H3Event } from 'h3'

export const useCookieProxy = async (event: H3Event, url: string) => {
  const res = await $fetch.raw(url)
  const cookies = res.headers.getSetCookie()
  for (const cookie of cookies) {
    appendResponseHeader(event, 'set-cookie', cookie)
  }
  return res._data
}

// middleware/auth.ts
import { useCookieProxy } from '~/composables/useCookieProxy'

export default defineNuxtRouteMiddleware(async (to, from) => {
  const event = useRequestEvent()
  const authCookie = useCookie('auth_token')
if (process.server && event) {
    // Server-side: use the composable to ensure cookie is passed correctly
    const result = await useCookieProxy(event, '/api/auth/check')
    if (!result.success) {
      return navigateTo('/dashboard/auth/login')
    }
  } else if (process.client) {
    // Client-side: check the cookie value
    if (!authCookie.value) {
      console.log('Client: redirecting to login')
      return navigateTo('/dashboard/auth/login')
    }
  }

  console.log('User authenticated, proceeding to route')
})

// middleware/auth.ts
import { useCookieProxy } from '~/composables/useCookieProxy'

export default defineNuxtRouteMiddleware(async (to, from) => {
  const event = useRequestEvent()
  const authCookie = useCookie('auth_token')
if (process.server && event) {
    // Server-side: use the composable to ensure cookie is passed correctly
    const result = await useCookieProxy(event, '/api/auth/check')
    if (!result.success) {
      return navigateTo('/dashboard/auth/login')
    }
  } else if (process.client) {
    // Client-side: check the cookie value
    if (!authCookie.value) {
      console.log('Client: redirecting to login')
      return navigateTo('/dashboard/auth/login')
    }
  }

  console.log('User authenticated, proceeding to route')
})

// server/api/auth/check.ts
export default defineEventHandler(async (event) => {
  // Your authentication logic here
  if (authenticated) {
    setCookie(event, 'auth_token', 'your_token_value', {
      httpOnly: true,
      path: '/',
      sameSite: 'strict'
    })
    return { success: true }
  }
  return { success: false, message: 'Not connected' }
})

// server/api/auth/check.ts
export default defineEventHandler(async (event) => {
  // Your authentication logic here
  if (authenticated) {
    setCookie(event, 'auth_token', 'your_token_value', {
      httpOnly: true,
      path: '/',
      sameSite: 'strict'
    })
    return { success: true }
  }
  return { success: false, message: 'Not connected' }
})

// After setting the cookie
refreshCookie('auth_token')

// After setting the cookie
refreshCookie('auth_token')

// middleware/auth.ts
import { useCookieProxy } from '~/composables/useCookieProxy'

export default defineNuxtRouteMiddleware(async (to, from) => {
  const event = useRequestEvent()
  const authCookie = useCookie('auth_token')

  if (process.server && event) {
    // Server-side: use the composable to ensure cookie is passed correctly
    const result = await useCookieProxy(event, '/api/auth/check')
    if (!result.success) {
      console.log('Server: redirecting to login')
      return navigateTo('/dashboard/auth/login')
    }
  } else if (process.client) {
    // Client-side: check the cookie value
    if (!authCookie.value) {
      console.log('Client: redirecting to login')
      return navigateTo('/dashboard/auth/login')
    }
  }

  console.log('User authenticated, proceeding to route')
})

// middleware/auth.ts
import { useCookieProxy } from '~/composables/useCookieProxy'

export default defineNuxtRouteMiddleware(async (to, from) => {
  const event = useRequestEvent()
  const authCookie = useCookie('auth_token')

  if (process.server && event) {
    // Server-side: use the composable to ensure cookie is passed correctly
    const result = await useCookieProxy(event, '/api/auth/check')
    if (!result.success) {
      console.log('Server: redirecting to login')
      return navigateTo('/dashboard/auth/login')
    }
  } else if (process.client) {
    // Client-side: check the cookie value
    if (!authCookie.value) {
      console.log('Client: redirecting to login')
      return navigateTo('/dashboard/auth/login')
    }
  }

  console.log('User authenticated, proceeding to route')
})

// composables/useCookieProxy.ts
import { appendResponseHeader } from 'h3'
import type { H3Event } from 'h3'

export const useCookieProxy = async (event: H3Event, url: string) => {
  const res = await $fetch.raw(url)
  const cookies = res.headers.getSetCookie()
  for (const cookie of cookies) {
    appendResponseHeader(event, 'set-cookie', cookie)
  }
  return res._data
}

// composables/useCookieProxy.ts
import { appendResponseHeader } from 'h3'
import type { H3Event } from 'h3'

export const useCookieProxy = async (event: H3Event, url: string) => {
  const res = await $fetch.raw(url)
  const cookies = res.headers.getSetCookie()
  for (const cookie of cookies) {
    appendResponseHeader(event, 'set-cookie', cookie)
  }
  return res._data
}

// server/api/auth/check.ts
export default defineEventHandler(async (event) => {
  const authCookie = getCookie(event, 'auth_token')
  
  if (authCookie) {
    // Your authentication logic here
    // For example, verify the JWT token
    // If valid:
    return { success: true }
  }
  
  // If not authenticated
  return { success: false, message: 'Not connected' }
})

// server/api/auth/check.ts
export default defineEventHandler(async (event) => {
  const authCookie = getCookie(event, 'auth_token')
  
  if (authCookie) {
    // Your authentication logic here
    // For example, verify the JWT token
    // If valid:
    return { success: true }
  }
  
  // If not authenticated
  return { success: false, message: 'Not connected' }
})

// server/api/auth/login.ts
export default defineEventHandler(async (event) => {
  // Your login logic here
  // If login is successful:
  const token = 'your_generated_jwt_token'
  setCookie(event, 'auth_token', token, {
    httpOnly: true,
    path: '/',
    sameSite: 'strict',
    secure: process.env.NODE_ENV === 'production' // Use secure in production
  })
  return { success: true }
  
  // If login fails:
  // return { success: false, message: 'Invalid credentials' }
})

// server/api/auth/login.ts
export default defineEventHandler(async (event) => {
  // Your login logic here
  // If login is successful:
  const token = 'your_generated_jwt_token'
  setCookie(event, 'auth_token', token, {
    httpOnly: true,
    path: '/',
    sameSite: 'strict',
    secure: process.env.NODE_ENV === 'production' // Use secure in production
  })
  return { success: true }
  
  // If login fails:
  // return { success: false, message: 'Invalid credentials' }
})

// nuxt.config.ts
export default defineNuxtConfig({
  experimental: {
    cookieStore: true
  },
  // ... other configurations
})

// nuxt.config.ts
export default defineNuxtConfig({
  experimental: {
    cookieStore: true
  },
  // ... other configurations
})

<!-- pages/dashboard/overview.vue -->
<template>
  <div>
    <h1>Dashboard Overview</h1>
    <p>Welcome, {{ user.name }}</p>
  </div>
</template>

<script setup lang="ts">
const { data: user } = await useFetch('/api/user')

// Refresh the cookie value to ensure it's up-to-date
if (process.client) {
  refreshCookie('auth_token')
}
</script>

<!-- pages/dashboard/overview.vue -->
<template>
  <div>
    <h1>Dashboard Overview</h1>
    <p>Welcome, {{ user.name }}</p>
  </div>
</template>

<script setup lang="ts">
const { data: user } = await useFetch('/api/user')

// Refresh the cookie value to ensure it's up-to-date
if (process.client) {
  refreshCookie('auth_token')
}
</script>

// server/api/user.ts
export default defineEventHandler(async (event) => {
  const authCookie = getCookie(event, 'auth_token')
  
  if (!authCookie) {
    throw createError({
      statusCode: 401,
      message: 'Unauthorized'
    })
  }
  
  // Your logic to fetch user data based on the auth token
  // For example:
  return {
    name: 'John Doe',
    email: '[email protected]'
  }
})

// server/api/user.ts
export default defineEventHandler(async (event) => {
  const authCookie = getCookie(event, 'auth_token')
  
  if (!authCookie) {
    throw createError({
      statusCode: 401,
      message: 'Unauthorized'
    })
  }
  
  // Your logic to fetch user data based on the auth token
  // For example:
  return {
    name: 'John Doe',
    email: '[email protected]'
  }
})

// composables/useCookieProxy.ts
import { appendResponseHeader, getRequestHeaders } from 'h3'
import type { H3Event } from 'h3'

export const useCookieProxy = async (event: H3Event, url: string) => {
  const headers = getRequestHeaders(event)
  const res = await $fetch.raw(url, {
    headers: {
      cookie: headers.cookie || ''
    }
  })
  const cookies = res.headers.getSetCookie()
  for (const cookie of cookies) {
    appendResponseHeader(event, 'set-cookie', cookie)
  }
  return res._data
}

// composables/useCookieProxy.ts
import { appendResponseHeader, getRequestHeaders } from 'h3'
import type { H3Event } from 'h3'

export const useCookieProxy = async (event: H3Event, url: string) => {
  const headers = getRequestHeaders(event)
  const res = await $fetch.raw(url, {
    headers: {
      cookie: headers.cookie || ''
    }
  })
  const cookies = res.headers.getSetCookie()
  for (const cookie of cookies) {
    appendResponseHeader(event, 'set-cookie', cookie)
  }
  return res._data
}

// middleware/auth.ts
import { useCookieProxy } from '~/composables/useCookieProxy'

export default defineNuxtRouteMiddleware(async (to, from) => {
  const event = useRequestEvent()
  const authCookie = useCookie('auth_token')
if (process.server && event) {
    // Server-side: use the composable to ensure cookie is passed correctly
    const result = await useCookieProxy(event, '/api/auth/check')
    console.log('Server-side auth check result:', result)
    if (!result.success) {
      console.log('Server: redirecting to login')
      return navigateTo('/dashboard/auth/login')
    }
  } else if (process.client) {
    // Client-side: check the cookie value
    if (!authCookie.value) {
      console.log('Client: redirecting to login')
      return navigateTo('/dashboard/auth/login')
    }
  }

  console.log('User authenticated, proceeding to route')
})

// middleware/auth.ts
import { useCookieProxy } from '~/composables/useCookieProxy'

export default defineNuxtRouteMiddleware(async (to, from) => {
  const event = useRequestEvent()
  const authCookie = useCookie('auth_token')
if (process.server && event) {
    // Server-side: use the composable to ensure cookie is passed correctly
    const result = await useCookieProxy(event, '/api/auth/check')
    console.log('Server-side auth check result:', result)
    if (!result.success) {
      console.log('Server: redirecting to login')
      return navigateTo('/dashboard/auth/login')
    }
  } else if (process.client) {
    // Client-side: check the cookie value
    if (!authCookie.value) {
      console.log('Client: redirecting to login')
      return navigateTo('/dashboard/auth/login')
    }
  }

  console.log('User authenticated, proceeding to route')
})

// server/api/auth/check.ts
export default defineEventHandler(async (event) => {
  const authCookie = getCookie(event, 'auth_token')
  console.log('Received auth_token:', authCookie)
  
  if (authCookie) {
    // Your authentication logic here
    // For example, verify the JWT token
    // If valid:
    return { success: true }
  }
  
  // If not authenticated
  return { success: false, message: 'Not connected' }
})

// server/api/auth/check.ts
export default defineEventHandler(async (event) => {
  const authCookie = getCookie(event, 'auth_token')
  console.log('Received auth_token:', authCookie)
  
  if (authCookie) {
    // Your authentication logic here
    // For example, verify the JWT token
    // If valid:
    return { success: true }
  }
  
  // If not authenticated
  return { success: false, message: 'Not connected' }
})

// composables/useCookieProxy.ts
import { appendResponseHeader, getRequestHeaders } from 'h3'
import type { H3Event } from 'h3'

export const useCookieProxy = async (event: H3Event, url: string) => {
  const headers = getRequestHeaders(event)
  const res = await $fetch.raw(url, {
    headers: {
      cookie: headers.cookie || ''
    }
  })
  return res._data
}

// composables/useCookieProxy.ts
import { appendResponseHeader, getRequestHeaders } from 'h3'
import type { H3Event } from 'h3'

export const useCookieProxy = async (event: H3Event, url: string) => {
  const headers = getRequestHeaders(event)
  const res = await $fetch.raw(url, {
    headers: {
      cookie: headers.cookie || ''
    }
  })
  return res._data
}

<!-- pages/dashboard/overview.vue -->
<template>
  <div>
    <h1>Dashboard Overview</h1>
    <p v-if="user">Welcome, {{ user.name }}</p>
    <p v-else>Loading user data...</p>
  </div>
</template>

<script setup lang="ts">
const event = useRequestEvent()
const { data: user, error } = await useAsyncData('user', () => 
  useCookieProxy(event, '/api/user')
)

if (error.value) {
  console.error('Error fetching user data:', error.value)
}
</script>

<!-- pages/dashboard/overview.vue -->
<template>
  <div>
    <h1>Dashboard Overview</h1>
    <p v-if="user">Welcome, {{ user.name }}</p>
    <p v-else>Loading user data...</p>
  </div>
</template>

<script setup lang="ts">
const event = useRequestEvent()
const { data: user, error } = await useAsyncData('user', () => 
  useCookieProxy(event, '/api/user')
)

if (error.value) {
  console.error('Error fetching user data:', error.value)
}
</script>

// server/api/user.ts
export default defineEventHandler(async (event) => {
  const authCookie = getCookie(event, 'auth_token')
  console.log('Received auth_token in /api/user:', authCookie)
  
  if (authCookie) {
    // Your authentication logic here
    // For example, verify the JWT token
    // If valid:
    return {
      success: true,
      user: {
        name: 'John Doe',
        email: '[email protected]'
      }
    }
  }
  
  // If not authenticated
  throw createError({
    statusCode: 401,
    message: 'Unauthorized'
  })
})

// server/api/user.ts
export default defineEventHandler(async (event) => {
  const authCookie = getCookie(event, 'auth_token')
  console.log('Received auth_token in /api/user:', authCookie)
  
  if (authCookie) {
    // Your authentication logic here
    // For example, verify the JWT token
    // If valid:
    return {
      success: true,
      user: {
        name: 'John Doe',
        email: '[email protected]'
      }
    }
  }
  
  // If not authenticated
  throw createError({
    statusCode: 401,
    message: 'Unauthorized'
  })
})

// nuxt.config.ts
export default defineNuxtConfig({
  experimental: {
    cookieStore: true
  },
  runtimeConfig: {
    cookieName: 'auth_token',
    cookieSecret: 'your-secret-key' // Use a secure secret in production
  }
})

// nuxt.config.ts
export default defineNuxtConfig({
  experimental: {
    cookieStore: true
  },
  runtimeConfig: {
    cookieName: 'auth_token',
    cookieSecret: 'your-secret-key' // Use a secure secret in production
  }
})

// composables/useCookieProxy.ts
import { appendResponseHeader, getRequestHeaders } from 'h3'
import type { H3Event } from 'h3'

export const useCookieProxy = async (event: H3Event, url: string) => {
  const headers = getRequestHeaders(event)
  const res = await $fetch.raw(url, {
    headers: {
      cookie: headers.cookie || ''
    }
  })
  return res._data
}

// composables/useCookieProxy.ts
import { appendResponseHeader, getRequestHeaders } from 'h3'
import type { H3Event } from 'h3'

export const useCookieProxy = async (event: H3Event, url: string) => {
  const headers = getRequestHeaders(event)
  const res = await $fetch.raw(url, {
    headers: {
      cookie: headers.cookie || ''
    }
  })
  return res._data
}

<!-- pages/dashboard/overview.vue -->
<template>
  <div>
    <h1>Dashboard Overview</h1>
    <p v-if="user">Welcome, {{ user.name }}</p>
    <p v-else>Loading user data...</p>
  </div>
</template>

<script setup lang="ts">
const event = useRequestEvent()
const { data: userData, error } = await useAsyncData('user', () => 
  useCookieProxy(event, '/api/user')
)

const user = computed(() => userData.value?.user)

if (error.value) {
  console.error('Error fetching user data:', error.value)
}
</script>

<!-- pages/dashboard/overview.vue -->
<template>
  <div>
    <h1>Dashboard Overview</h1>
    <p v-if="user">Welcome, {{ user.name }}</p>
    <p v-else>Loading user data...</p>
  </div>
</template>

<script setup lang="ts">
const event = useRequestEvent()
const { data: userData, error } = await useAsyncData('user', () => 
  useCookieProxy(event, '/api/user')
)

const user = computed(() => userData.value?.user)

if (error.value) {
  console.error('Error fetching user data:', error.value)
}
</script>

// server/api/user.ts
export default defineEventHandler(async (event) => {
  const authCookie = getCookie(event, 'auth_token')
  console.log('Received auth_token in /api/user:', authCookie)
  
  if (authCookie) {
    // Your authentication logic here
    // For example, verify the JWT token
    // If valid:
    return {
      success: true,
      user: {
        name: 'John Doe',
        email: '[email protected]'
      }
    }
  }
  
  // If not authenticated
  return { success: false, message: 'Not connected' }
})

// server/api/user.ts
export default defineEventHandler(async (event) => {
  const authCookie = getCookie(event, 'auth_token')
  console.log('Received auth_token in /api/user:', authCookie)
  
  if (authCookie) {
    // Your authentication logic here
    // For example, verify the JWT token
    // If valid:
    return {
      success: true,
      user: {
        name: 'John Doe',
        email: '[email protected]'
      }
    }
  }
  
  // If not authenticated
  return { success: false, message: 'Not connected' }
})

// nuxt.config.ts
export default defineNuxtConfig({
  experimental: {
    cookieStore: true
  },
  runtimeConfig: {
    cookieName: 'auth_token',
    cookieSecret: 'your-secret-key' // Use a secure secret in production
  }
})

// nuxt.config.ts
export default defineNuxtConfig({
  experimental: {
    cookieStore: true
  },
  runtimeConfig: {
    cookieName: 'auth_token',
    cookieSecret: 'your-secret-key' // Use a secure secret in production
  }
})