Sign in with GitHub

1
import { NextResponse } from 'next/server'
2
3
// The client you created from the Server-Side Auth instructions
4
import { createClient } from '@/utils/supabase/server'
5
6
export async function GET(request: Request) {
7
  const { searchParams, origin } = new URL(request.url)
8
  const code = searchParams.get('code')
9
  // if "next" is in param, use it as the redirect URL
10
  let next = searchParams.get('next') ?? '/'
11
  if (!next.startsWith('/')) {
12
    // if "next" is not a relative URL, use the default
13
    next = '/'
14
  }
15
16
  if (code) {
17
    const supabase = await createClient()
18
    const { error } = await supabase.auth.exchangeCodeForSession(code)
19
    if (!error) {
20
      const forwardedHost = request.headers.get('x-forwarded-host') // original origin before load balancer
21
      const isLocalEnv = process.env.NODE_ENV === 'development'
22
      if (isLocalEnv) {
23
        // we can be sure that there is no load balancer in between, so no need to watch for X-Forwarded-Host
24
        return NextResponse.redirect(`${origin}${next}`)
25
      } else if (forwardedHost) {
26
        return NextResponse.redirect(`https://${forwardedHost}${next}`)
27
      } else {
28
        return NextResponse.redirect(`${origin}${next}`)
29
      }
30
    }
31
  }
32
33
  // return the user to an error page with instructions
34
  return NextResponse.redirect(`${origin}/auth/auth-code-error`)
35
}

1
import { redirect } from '@sveltejs/kit'
2
3
export const GET = async (event) => {
4
  const {
5
    url,
6
    locals: { supabase },
7
  } = event
8
  const code = url.searchParams.get('code')
9
  const next = url.searchParams.get('next') ?? '/'
10
11
  if (code) {
12
    const { error } = await supabase.auth.exchangeCodeForSession(code)
13
    if (!error) {
14
      redirect(303, `/${next.slice(1)}`)
15
    }
16
  }
17
18
  // return the user to an error page with instructions
19
  redirect(303, '/auth/auth-code-error')
20
}

1
import { createServerClient, parseCookieHeader } from '@supabase/ssr'
2
import { type APIRoute } from 'astro'
3
4
export const GET: APIRoute = async ({ request, cookies, redirect }) => {
5
  const requestUrl = new URL(request.url)
6
  const code = requestUrl.searchParams.get('code')
7
  const next = requestUrl.searchParams.get('next') || '/'
8
9
  if (code) {
10
    const supabase = createServerClient(
11
      import.meta.env.PUBLIC_SUPABASE_URL,
12
      import.meta.env.PUBLIC_SUPABASE_PUBLISHABLE_KEY,
13
      {
14
        cookies: {
15
          getAll() {
16
            return parseCookieHeader(Astro.request.headers.get('Cookie') ?? '')
17
          },
18
          setAll(cookiesToSet, _headers) {
19
            cookiesToSet.forEach(({ name, value, options }) =>
20
              Astro.cookies.set(name, value, options)
21
            )
22
          },
23
        },
24
      }
25
    )
26
27
    const { error } = await supabase.auth.exchangeCodeForSession(code)
28
29
    if (!error) {
30
      return redirect(next)
31
    }
32
  }
33
34
  // return the user to an error page with instructions
35
  return redirect('/auth/auth-code-error')
36
}

1
import { redirect, type LoaderFunctionArgs } from '@remix-run/node'
2
import { createServerClient, parseCookieHeader, serializeCookieHeader } from '@supabase/ssr'
3
4
export async function loader({ request }: LoaderFunctionArgs) {
5
  const requestUrl = new URL(request.url)
6
  const code = requestUrl.searchParams.get('code')
7
  const next = requestUrl.searchParams.get('next') || '/'
8
  const responseHeaders = new Headers()
9
10
  if (code) {
11
    const supabase = createServerClient(
12
      process.env.SUPABASE_URL!,
13
      process.env.SUPABASE_PUBLISHABLE_KEY!,
14
      {
15
        cookies: {
16
          getAll() {
17
            return parseCookieHeader(request.headers.get('Cookie') ?? '')
18
          },
19
          setAll(cookiesToSet, cacheHeaders) {
20
            cookiesToSet.forEach(({ name, value, options }) =>
21
              responseHeaders.append('Set-Cookie', serializeCookieHeader(name, value, options))
22
            )
23
            Object.entries(cacheHeaders).forEach(([key, value]) => responseHeaders.set(key, value))
24
          },
25
        },
26
      }
27
    )
28
29
    const { error } = await supabase.auth.exchangeCodeForSession(code)
30
31
    if (!error) {
32
      return redirect(next, { headers: responseHeaders })
33
    }
34
  }
35
36
  // return the user to an error page with instructions
37
  return redirect('/auth/auth-code-error', { headers: responseHeaders })
38
}

1
...
2
app.get("/auth/callback", async function (req, res) {
3
  const code = req.query.code
4
  const next = req.query.next ?? "/"
5
6
  if (code) {
7
    const supabase = createServerClient(
8
      process.env.SUPABASE_URL,
9
      process.env.SUPABASE_PUBLISHABLE_KEY, {
10
    cookies: {
11
      getAll() {
12
        return parseCookieHeader(req.headers.cookie ?? '')
13
      },
14
      setAll(cookiesToSet, headers) {
15
        cookiesToSet.forEach(({ name, value, options }) =>
16
          res.appendHeader('Set-Cookie', serializeCookieHeader(name, value, options))
17
        )
18
        Object.entries(headers).forEach(([key, value]) =>
19
          res.setHeader(key, value)
20
        )
21
      },
22
    },
23
  })
24
    await supabase.auth.exchangeCodeForSession(code)
25
  }
26
27
  res.redirect(303, `/${next.slice(1)}`)
28
})