Live Preview with Next.js and Sanity.io: A Complete Guide

// ./studio/schemas/article.js

export default {
  name: 'article',
  title: 'Article',
  type: 'document',
  fields: [
    {name: 'title', type: 'string'},
    // Important! Document needs a slug for Next.js to query for.
    {name: 'slug', type: 'slug', options: {source: 'title'}},
    {name: 'content', type: 'text'},
  ],
}

// ./studio/schemas/schema.js

import createSchema from 'part:@sanity/base/schema-creator'
import schemaTypes from 'all:part:@sanity/base/schema-type'
import article from './article'

export default createSchema({
  name: 'default',
  types: schemaTypes.concat([article]),
})

// ./web/.env.local

// Find these in sanity.json
NEXT_PUBLIC_SANITY_DATASET='production'
NEXT_PUBLIC_SANITY_PROJECT_ID='...'

// Create this in sanity.io/manage
SANITY_API_TOKEN='...'

// Blank for now, we'll get back to this!
SANITY_PREVIEW_SECRET='' 

// ./web/pages/[slug].js

import React from 'react'
import {groq} from 'next-sanity'

import {usePreviewSubscription} from '../lib/sanity'
import {getClient} from '../lib/sanity.server'

/**
 * Helper function to return the correct version of the document
 * If we're in "preview mode" and have multiple documents, return the draft
 */
function filterDataToSingleItem(data, preview) {
  if (!Array.isArray(data)) {
    return data
  }

  if (data.length === 1) {
    return data[0]
  }

  if (preview) {
    return data.find((item) => item._id.startsWith(`drafts.`)) || data[0]
  }

  return data[0]
}

/**
 * Makes Next.js aware of all the slugs it can expect at this route
 *
 * See how we've mapped over our found slugs to add a `/` character?
 * Idea: Add these in Sanity and enforce them with validation rules :)
 * https://www.simeongriggs.dev/nextjs-sanity-slug-patterns
 */
export async function getStaticPaths() {
  const allSlugsQuery = groq`*[defined(slug.current)][].slug.current`
  const pages = await getClient().fetch(allSlugsQuery)

  return {
    paths: pages.map((slug) => `/${slug}`),
    fallback: true,
  }
}

/**
 * Fetch the data from Sanity based on the current slug
 *
 * Important: You _could_ query for just one document, like this:
 * *[slug.current == $slug][0]
 * But that won't return a draft document!
 * And you get a better editing experience 
 * fetching draft/preview content server-side
 *
 * Also: Ignore the `preview = false` param!
 * It's set by Next.js "Preview Mode" 
 * It does not need to be set or changed here
 */
export async function getStaticProps({params, preview = false}) {
  const query = groq`*[_type == "article" && slug.current == $slug]`
  const queryParams = {slug: params.slug}
  const data = await getClient(preview).fetch(query, queryParams)

  // Escape hatch, if our query failed to return data
  if (!data) return {notFound: true}

  // Helper function to reduce all returned documents down to just one
  const page = filterDataToSingleItem(data, preview)

  return {
    props: {
      // Pass down the "preview mode" boolean to the client-side
      preview,
      // Pass down the initial content, and our query
      data: {page, query, queryParams}
    }
  }
}

/**
 * The `usePreviewSubscription` takes care of updating
 * the preview content on the client-side
 */
export default function Page({data, preview}) {
  const {data: previewData} = usePreviewSubscription(data?.query, {
    params: data?.queryParams ?? {},
    // The hook will return this on first render
    // This is why it's important to fetch *draft* content server-side!
    initialData: data?.page,
    // The passed-down preview context determines whether this function does anything
    enabled: preview,
  })

  // Client-side uses the same query, so we may need to filter it down again
  const page = filterDataToSingleItem(previewData, preview)

  // Notice the optional?.chaining conditionals wrapping every piece of content? 
  // This is extremely important as you can't ever rely on a single field
  // of data existing when Editors are creating new documents. 
  // It'll be completely blank when they start!
  return (
    <div style={{maxWidth: `20rem`, padding: `1rem`}}>
      {page?.title && <h1>{page.title}</h1>}
      {page?.content && <p>{page.content}</p>}
    </div>
  )
}

// ./web/lib/queries.js

export const articleBySlugQuery = `
  *[_type == "article" && slug.current == $slug][0] {
    "slug": slug.current
  }
`

// ./web/pages/api/preview.js

import {articleBySlugQuery} from '../../lib/queries'
import {previewClient} from '../../lib/sanity.server'

function redirectToPreview(res, Location) {
  // Enable preview mode by setting the cookies
  res.setPreviewData({})

  // Redirect to a preview capable route
  res.writeHead(307, {Location})
  res.end()
}

export default async function preview(req, res) {
  const {secret, slug} = req.query

  if (!secret) {
    return res.status(401).json({message: 'No secret token'})
  }

  // Check the secret and next parameters
  // This secret should only be known to this API route and the CMS
  if (secret !== process.env.SANITY_PREVIEW_SECRET) {
    return res.status(401).json({message: 'Invalid secret'})
  }

  if (!slug) {
    return redirectToPreview(res, '/')
  }

  // Check if the article with the given `slug` exists
  const article = await previewClient.fetch(articleBySlugQuery, {slug})

  // If the slug doesn't exist prevent preview mode from being enabled
  if (!article) {
    return res.status(401).json({message: 'Invalid slug'})
  }

  // Redirect to the path from the fetched article
  // We don't redirect to req.query.slug as that might lead to open redirect vulnerabilities
  return redirectToPreview(res, `/${article.slug}`)
}

// ./web/pages/api/exit-preview.js

export default function exit(req, res) {
  // Exit current user from preview mode
  res.clearPreviewData()

  // Redirect user back to the index page
  res.writeHead(307, {Location: '/'})
  res.end()
}

// ./studio/sanity.json

parts: [
  // ...all other parts
  {
    "implements": "part:@sanity/production-preview/resolve-production-url",
    "path": "./resolveProductionUrl.js"
  },

// ./studio/resolveProductionUrl.js

// Any random string, must match SANITY_PREVIEW_SECRET in the Next.js .env.local file
const previewSecret = 'j8heapkqy4rdz6kudrvsc7ywpvfhrv022abyx5zgmuwpc1xv'

// Replace `remoteUrl` with your deployed Next.js site
const remoteUrl = `https://your-nextjs-site.com`
const localUrl = `http://localhost:3000`

export default function resolveProductionUrl(doc) {
  const baseUrl = window.location.hostname === 'localhost' ? localUrl : remoteUrl

  const previewUrl = new URL(baseUrl)

  previewUrl.pathname = `/api/preview`
  previewUrl.searchParams.append(`secret`, previewSecret)
  if (doc?.slug?.current) {
    previewUrl.searchParams.append(`slug`, doc.slug.current)
  }

  return previewUrl.toString()
}

import Link from 'next/link'

// ... everything else

{preview && <Link href="/api/exit-preview">Preview Mode Activated!</Link>}

// ./studio/sanity.json

parts: [
  // ...all other parts
  {
    "name": "part:@sanity/desk-tool/structure",
    "path": "./deskStructure.js"
  },

// ./studio/deskStructure.js

import S from '@sanity/desk-tool/structure-builder'
import Iframe from 'sanity-plugin-iframe-pane'

import resolveProductionUrl from './resolveProductionUrl'

export const getDefaultDocumentNode = () => {
  return S.document().views([
    S.view.form(),
    S.view
      .component(Iframe)
      .options({
        url: (doc) => resolveProductionUrl(doc),
        reload: {button: true},
      })
      .title('Preview'),
  ])
}

export default () =>
  S.list()
    .title('Content')
    .items([S.documentTypeListItem('article')])