Authentication API

// Using Supabase client
import { createClient } from '@/lib/supabase/client'
 
const supabase = createClient()
 
const { data, error } = await supabase.auth.signUp({
  email: 'user@example.com',
  password: 'securepassword',
  options: {
    data: {
      first_name: 'Kwame',
      last_name: 'Asante'
    }
  }
})

{
  "user": {
    "id": "uuid-here",
    "email": "user@example.com",
    "user_metadata": {
      "first_name": "Kwame",
      "last_name": "Asante"
    }
  },
  "session": null // Email confirmation required
}

const { data, error } = await supabase.auth.signInWithPassword({
  email: 'user@example.com',
  password: 'securepassword'
})

const { data, error } = await supabase.auth.signInWithOAuth({
  provider: 'google',
  options: {
    redirectTo: `${window.location.origin}/auth/callback`
  }
})

const { data, error } = await supabase.auth.signInWithOtp({
  email: 'user@example.com',
  options: {
    emailRedirectTo: `${window.location.origin}/auth/callback`
  }
})

// app/auth/callback/route.ts
import { createClient } from '@/lib/supabase/server'
import { NextResponse } from 'next/server'
 
export async function GET(request: Request) {
  const { searchParams } = new URL(request.url)
  const code = searchParams.get('code')
  const next = searchParams.get('next') ?? '/dashboard'
 
  if (code) {
    const supabase = await createClient()
    const { error } = await supabase.auth.exchangeCodeForSession(code)
 
    if (!error) {
      return NextResponse.redirect(new URL(next, request.url))
    }
  }
 
  return NextResponse.redirect(new URL('/auth/error', request.url))
}

const { error } = await supabase.auth.signOut()

const { data: { user } } = await supabase.auth.getUser()

// In Server Component or Server Action
import { createClient } from '@/lib/supabase/server'
 
const supabase = await createClient()
const { data: { user } } = await supabase.auth.getUser()

const { data, error } = await supabase.auth.resetPasswordForEmail(
  'user@example.com',
  {
    redirectTo: `${window.location.origin}/auth/reset-password`
  }
)

const { data, error } = await supabase.auth.updateUser({
  password: 'newSecurePassword'
})

const { data: { session } } = await supabase.auth.getSession()

const { data, error } = await supabase.auth.refreshSession()

// lib/auth.ts
import { createClient } from '@/lib/supabase/server'
import { prisma } from '@/lib/db'
 
export async function getCurrentUser() {
  const supabase = await createClient()
  const { data: { user } } = await supabase.auth.getUser()
 
  if (!user) return null
 
  // Find or create user in our database
  let dbUser = await prisma.user.findUnique({
    where: { id: user.id },
    include: { profile: true }
  })
 
  if (!dbUser) {
    dbUser = await prisma.user.create({
      data: {
        id: user.id,
        email: user.email!,
        emailVerified: user.email_confirmed_at ? new Date() : null,
        profile: {
          create: {
            firstName: user.user_metadata.first_name || '',
            lastName: user.user_metadata.last_name || '',
            avatarUrl: user.user_metadata.avatar_url
          }
        }
      },
      include: { profile: true }
    })
  }
 
  return dbUser
}

// middleware.ts
import { createServerClient } from '@supabase/ssr'
import { NextResponse, type NextRequest } from 'next/server'
 
export async function middleware(request: NextRequest) {
  const response = NextResponse.next()
 
  const supabase = createServerClient(
    process.env.NEXT_PUBLIC_SUPABASE_URL!,
    process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
    {
      cookies: {
        getAll() {
          return request.cookies.getAll()
        },
        setAll(cookiesToSet) {
          cookiesToSet.forEach(({ name, value, options }) =>
            response.cookies.set(name, value, options)
          )
        },
      },
    }
  )
 
  const { data: { user } } = await supabase.auth.getUser()
 
  // Redirect unauthenticated users
  const protectedPaths = ['/dashboard', '/host', '/admin']
  const isProtected = protectedPaths.some(path =>
    request.nextUrl.pathname.startsWith(path)
  )
 
  if (isProtected && !user) {
    const loginUrl = new URL('/login', request.url)
    loginUrl.searchParams.set('next', request.nextUrl.pathname)
    return NextResponse.redirect(loginUrl)
  }
 
  return response
}
 
export const config = {
  matcher: ['/dashboard/:path*', '/host/:path*', '/admin/:path*']
}