Server-Side Operations

/**
 * Get all cookies from server-side context
 * @param options - Server context (req/res objects or Next.js cookies function)
 * @returns Promise resolving to object containing all cookies
 */
function getCookies(options?: OptionsType): Promise<TmpCookiesObj>;

import { getCookies } from 'cookies-next/server';
import { cookies } from 'next/headers';

// Next.js App Router - Server Component
export default async function ServerComponent() {
  const allCookies = await getCookies({ cookies });
  console.log('All cookies:', allCookies);
  return <div>Cookie count: {Object.keys(allCookies).length}</div>;
}

// Next.js API Route
export async function GET(request: Request) {
  const allCookies = await getCookies({ req: request });
  return Response.json({ cookies: allCookies });
}

// Traditional Next.js pages (getServerSideProps)
export async function getServerSideProps({ req, res }) {
  const allCookies = await getCookies({ req, res });
  return { props: { cookies: allCookies } };
}

// Express.js or Node.js HTTP server
app.get('/api/cookies', async (req, res) => {
  const allCookies = await getCookies({ req, res });
  res.json(allCookies);
});

/**
 * Get a specific cookie value by key from server-side context
 * @param key - Cookie name to retrieve
 * @param options - Server context (req/res objects or Next.js cookies function)
 * @returns Promise resolving to cookie value or undefined if not found
 */
function getCookie(key: string, options?: OptionsType): Promise<CookieValueTypes>;

import { getCookie } from 'cookies-next/server';
import { cookies } from 'next/headers';

// Next.js App Router - Server Component
export default async function UserProfile() {
  const userId = await getCookie('user-id', { cookies });
  if (!userId) {
    return <div>Please log in</div>;
  }
  return <div>Welcome, user {userId}</div>;
}

// Next.js App Router - Server Action
export async function updateProfile(formData: FormData) {
  'use server';
  const sessionToken = await getCookie('session-token', { cookies });
  if (!sessionToken) {
    throw new Error('Authentication required');
  }
  // Process form data...
}

// Next.js API Route
export async function POST(request: Request) {
  const authToken = await getCookie('auth-token', { req: request });
  if (!authToken) {
    return new Response('Unauthorized', { status: 401 });
  }
  // Process authenticated request...
}

// Middleware
export async function middleware(request: NextRequest) {
  const sessionId = await getCookie('session-id', { req: request });
  if (!sessionId && request.nextUrl.pathname.startsWith('/dashboard')) {
    return NextResponse.redirect(new URL('/login', request.url));
  }
}

/**
 * Set a cookie in server-side response
 * @param key - Cookie name
 * @param data - Cookie value (automatically stringified if object)
 * @param options - Server context and cookie options
 * @returns Promise that resolves when cookie is set
 */
function setCookie(key: string, data: any, options?: OptionsType): Promise<void>;

import { setCookie } from 'cookies-next/server';
import { cookies } from 'next/headers';
import { NextRequest, NextResponse } from 'next/server';

// Next.js App Router - Server Action
export async function loginAction(formData: FormData) {
  'use server';
  const email = formData.get('email');
  const password = formData.get('password');
  
  // Authenticate user...
  const sessionToken = generateSessionToken();
  
  await setCookie('session-token', sessionToken, {
    cookies,
    maxAge: 24 * 60 * 60, // 1 day
    httpOnly: true,
    secure: true,
    sameSite: 'strict'
  });
}

// Next.js API Route
export async function POST(request: Request) {
  const response = NextResponse.json({ success: true });
  
  await setCookie('api-session', 'active', {
    res: response,
    maxAge: 60 * 60, // 1 hour
    path: '/api'
  });
  
  return response;
}

// Traditional pages API route
export default async function handler(req, res) {
  await setCookie('last-visit', new Date().toISOString(), {
    req,
    res,
    maxAge: 30 * 24 * 60 * 60 // 30 days
  });
  
  res.json({ message: 'Cookie set' });
}

// Set structured data
await setCookie('user-preferences', {
  theme: 'dark',
  language: 'en',
  notifications: true
}, {
  cookies,
  maxAge: 365 * 24 * 60 * 60 // 1 year
});

/**
 * Delete a cookie from server-side response
 * @param key - Cookie name to delete
 * @param options - Server context and cookie options (should match original path/domain)
 * @returns Promise that resolves when cookie is deleted
 */
function deleteCookie(key: string, options?: OptionsType): Promise<void>;

import { deleteCookie } from 'cookies-next/server';
import { cookies } from 'next/headers';

// Next.js App Router - Server Action
export async function logoutAction() {
  'use server';
  await deleteCookie('session-token', { cookies });
  await deleteCookie('refresh-token', { cookies });
  redirect('/login');
}

// Next.js API Route - Logout
export async function POST(request: Request) {
  await deleteCookie('auth-token', { req: request });
  return NextResponse.json({ message: 'Logged out' });
}

// Delete cookie with specific path (must match original)
await deleteCookie('admin-session', {
  cookies,
  path: '/admin'
});

// Delete cookie with specific domain
await deleteCookie('tracking-id', {
  cookies,
  domain: '.example.com',
  path: '/'
});

/**
 * Check if a cookie exists in server-side context
 * @param key - Cookie name to check
 * @param options - Server context (req/res objects or Next.js cookies function)
 * @returns Promise resolving to true if cookie exists, false otherwise
 */
function hasCookie(key: string, options?: OptionsType): Promise<boolean>;

import { hasCookie } from 'cookies-next/server';
import { cookies } from 'next/headers';

// Next.js App Router - Server Component
export default async function ConditionalContent() {
  const hasSeenWelcome = await hasCookie('welcome-seen', { cookies });
  
  return (
    <div>
      {!hasSeenWelcome && <WelcomeMessage />}
      <MainContent />
    </div>
  );
}

// Next.js API Route - Authentication check
export async function GET(request: Request) {
  const isAuthenticated = await hasCookie('session-token', { req: request });
  
  if (!isAuthenticated) {
    return new Response('Authentication required', { status: 401 });
  }
  
  return NextResponse.json({ message: 'Welcome' });
}

// Conditional server action
export async function conditionalAction() {
  'use server';
  const hasConsent = await hasCookie('cookie-consent', { cookies });
  
  if (hasConsent) {
    // Set analytics cookies
    await setCookie('analytics-id', generateId(), { cookies });
  }
}

// Using the cookies() function from next/headers
import { cookies } from 'next/headers';

const options = { cookies }; // For Server Components and Server Actions

// Using req/res objects
const options = { req, res }; // For API routes and traditional servers

// Using NextRequest/NextResponse
const options = { 
  req: request,  // NextRequest
  res: response  // NextResponse
};

// Throws error if called on client-side
try {
  await setCookie('key', 'value'); // No context provided on client
} catch (error) {
  // Error: "You are trying to access cookies on the client side. 
  // Please, use the client-side import with `cookies-next/client` instead."
}

import { setCookie, getCookie } from 'cookies-next/server';
import { cookies } from 'next/headers';

// Server Component
export default async function Page() {
  const theme = await getCookie('theme', { cookies }) || 'light';
  return <div data-theme={theme}>Content</div>;
}

// Server Action
export async function updateTheme(theme: string) {
  'use server';
  await setCookie('theme', theme, {
    cookies,
    maxAge: 365 * 24 * 60 * 60 // 1 year
  });
  revalidatePath('/');
}