Redirecting

1
'use server'
2

3
import { redirect } from 'next/navigation'
4
import { revalidatePath } from 'next/cache'
5

6
export async function createPost(id: string) {
7
  try {
8
    // Call database
9
  } catch (error) {
10
    // Handle errors
11
  }
12

13
  revalidatePath('/posts') // Update cached posts
14
  redirect(`/post/${id}`) // Navigate to the new post page
15
}

1
'use server'
2

3
import { permanentRedirect } from 'next/navigation'
4
import { revalidateTag } from 'next/cache'
5

6
export async function updateUsername(username: string, formData: FormData) {
7
  try {
8
    // Call database
9
  } catch (error) {
10
    // Handle errors
11
  }
12

13
  revalidateTag('username') // Update all references to the username
14
  permanentRedirect(`/profile/${username}`) // Navigate to the new user profile
15
}

1
'use client'
2

3
import { useRouter } from 'next/navigation'
4

5
export default function Page() {
6
  const router = useRouter()
7

8
  return (
9
    <button type="button" onClick={() => router.push('/dashboard')}>
10
      Dashboard
11
    </button>
12
  )
13
}

1
module.exports = {
2
  async redirects() {
3
    return [
4
      // Basic redirect
5
      {
6
        source: '/about',
7
        destination: '/',
8
        permanent: true,
9
      },
10
      // Wildcard path matching
11
      {
12
        source: '/blog/:slug',
13
        destination: '/news/:slug',
14
        permanent: true,
15
      },
16
    ]
17
  },
18
}

1
import { NextResponse, NextRequest } from 'next/server'
2
import { authenticate } from 'auth-provider'
3

4
export function middleware(request: NextRequest) {
5
  const isAuthenticated = authenticate(request)
6

7
  // If the user is authenticated, continue as normal
8
  if (isAuthenticated) {
9
    return NextResponse.next()
10
  }
11

12
  // Redirect to login page if not authenticated
13
  return NextResponse.redirect(new URL('/login', request.url))
14
}
15

16
export const config = {
17
  matcher: '/dashboard/:path*',
18
}

1
{
2
  "/old": {
3
    "destination": "/new",
4
    "permanent": true
5
  },
6
  "/blog/post-old": {
7
    "destination": "/blog/post-new",
8
    "permanent": true
9
  }
10
}

1
import { NextResponse, NextRequest } from 'next/server'
2
import { get } from '@vercel/edge-config'
3

4
type RedirectEntry = {
5
  destination: string
6
  permanent: boolean
7
}
8

9
export async function middleware(request: NextRequest) {
10
  const pathname = request.nextUrl.pathname
11
  const redirectData = await get(pathname)
12

13
  if (redirectData && typeof redirectData === 'string') {
14
    const redirectEntry: RedirectEntry = JSON.parse(redirectData)
15
    const statusCode = redirectEntry.permanent ? 308 : 307
16
    return NextResponse.redirect(redirectEntry.destination, statusCode)
17
  }
18

19
  // No redirect found, continue without redirecting
20
  return NextResponse.next()
21
}

1
import { NextResponse, NextRequest } from 'next/server'
2
import { ScalableBloomFilter } from 'bloom-filters'
3
import GeneratedBloomFilter from './redirects/bloom-filter.json'
4

5
type RedirectEntry = {
6
  destination: string
7
  permanent: boolean
8
}
9

10
// Initialize bloom filter from a generated JSON file
11
const bloomFilter = ScalableBloomFilter.fromJSON(GeneratedBloomFilter as any)
12

13
export async function middleware(request: NextRequest) {
14
  // Get the path for the incoming request
15
  const pathname = request.nextUrl.pathname
16

17
  // Check if the path is in the bloom filter
18
  if (bloomFilter.has(pathname)) {
19
    // Forward the pathname to the Route Handler
20
    const api = new URL(
21
      `/api/redirects?pathname=${encodeURIComponent(request.nextUrl.pathname)}`,
22
      request.nextUrl.origin,
23
    )
24

25
    try {
26
      // Fetch redirect data from the Route Handler
27
      const redirectData = await fetch(api)
28

29
      if (redirectData.ok) {
30
        const redirectEntry: RedirectEntry | undefined = await redirectData.json()
31

32
        if (redirectEntry) {
33
          // Determine the status code
34
          const statusCode = redirectEntry.permanent ? 308 : 307
35

36
          // Redirect to the destination
37
          return NextResponse.redirect(redirectEntry.destination, statusCode)
38
        }
39
      }
40
    } catch (error) {
41
      console.error(error)
42
    }
43
  }
44

45
  // No redirect found, continue the request without redirecting
46
  return NextResponse.next()
47
}

1
import { NextRequest, NextResponse } from 'next/server'
2
import redirects from '@/app/redirects/redirects.json'
3

4
type RedirectEntry = {
5
  destination: string
6
  permanent: boolean
7
}
8

9
export function GET(request: NextRequest) {
10
  const pathname = request.nextUrl.searchParams.get('pathname')
11
  if (!pathname) {
12
    return new Response('Bad Request', { status: 400 })
13
  }
14

15
  // Get the redirect entry from the redirects.json file
16
  const redirect = (redirects as Record<string, RedirectEntry>)[pathname]
17

18
  // Account for bloom filter false positives
19
  if (!redirect) {
20
    return new Response('No redirect', { status: 400 })
21
  }
22

23
  // Return the redirect entry
24
  return NextResponse.json(redirect)
25
}