In this guide, you will learn about the importance of Previews in Jamstack. I will also walk you through the process of adding the previews mode to a blog built with Next.js and Strapi headless cms for a better content editing experience.

The Preview Mode

One of the major features/selling points of the Jamstack web development architecture is its core principle of pre-rendering, i.e., generating the website's content during build time instead of every request time. Pre-rendering improves the speed, reduces the complexity, and reduces the cost of hosting the website.

The pre-rendering process in the Jamstack web development methodology is achieved with the help of a static site generator(SSG). SSG collects content from a headless CMS - where the files are created and stored - with the help of an API.

The contents are then converted into their static files(prebuilt HTML, CSS, and Javascript files) by the SSG during the SSG build time. Finally, the generated static files are stored in a content delivery network(CDN) and serve as a whole to the end-user in every request.

Even though very beneficial, this pre-rendering process tends not to be ideal during content creation. Content creators and editors must render a draft preview at every request instead of waiting for the complete website build process before viewing their changes.

The easiest solution to the problem conferred by most Static Site Generators is setting up a Preview mode that will bypass the static site generator pre-rendering process. With the preview mode activated, content editors can view their changes on every page request instead of waiting for the complete build process to run.

Setting up the Preview mode

For this example guide, we will create a simple blog website for which we will later activate the previews mode to allow for a better editing experience.

Prerequisites

To follow through with the guide, you will need a basic knowledge of the following:

• Next.js - Next.js is our static site generator for this tutorial. Next.js is an open-source react framework used for building production-grade react websites. It comes with a preview API that we will use in this guide.

• Tailwind CSS - Tailwind CSS is a utility-first CSS framework. It enables you to add CSS directly to your Html for easier development and scaling.

• Strapi - Strapi is the leading open-source headless CMS for managing content efficiently and designing secure production-ready RestFul or GraphQL APIs.

• Markdown-to-jsx - We will use the Markdown-to-jsx npm package for converting the markdown files returned from Strapi into jsx to be rendered by Next.js

Strapi Setup

The first step in this guide will be creating our blog's backend. We will use the strapi blog template as a starter for faster and easier development.

1    npx create-strapi-app blog-backend  

The Blog template

You will be prompted for the installation type. Next, select quickstart to use the preconfigured settings. This command will create a new blog-backend folder with the Strapi backend fully set up and all dependencies installed during installation.

After the successful installation, you will automatically be redirected to your browser, where you will be prompted to register before using Strapi.

Add your details and click LET’S START to access the Strapi dashboard.

The blog template for Strapi comes with some preconfigured schema for blogging apps, making our development easier and faster.

Open the generated blogs-backend and navigate to the /api/article/models/article.settings.json file and replace the code with these lines of code.

1    {
2    "kind": "collectionType",
3     "collectionName": "articles",
4     "info": {
5      "name": "article",
6      "description": ""
7     },
8     "options": {
9       "increments": true,
10       "timestamps": true,
11       "draftAndPublish": false
12     },
13     "pluginOptions": {},
14     "attributes": {
15       "title": {
16         "type": "string",
17         "required": true
18       },
19       "description": {
20         "type": "text",
21        "required": true
22       },
23       "content": {
24         "type": "richtext",
25         "required": true
26       },
27       "publishedAt": {
28         "type": "datetime",
29         "required": true
30       },
31       "status": {
32         "type": "enumeration",
33         "enum": [
34           "draft",
35           "published"
36         ],
37         "required": true,
38         "default": "draft"
39       },
40       "slug": {
41         "type": "uid",
42         "targetField": "title",
43         "required": true
44       },
45      "category": {
46        "model": "category",
47        "via": "articles"
48       },
49       "image": {
50       "model": "file",
51        "via": "related",
52        "allowedTypes": [
53           "files",
54           "images",
55           "videos"
56         ],
57        "plugin": "upload",
58        "required": true,
59        "pluginOptions": {}
60       },
61       "author": {
62         "via": "articles",
63         "model": "writer"
64       }
65     }
66    }

Close your backend server and restart with yarn develop to register the changes. Then, log in to Strapi's dashboard again and set the Status of the articles in Collection types to either published or draft. Also, add a PublishedAt date, and save your changes.

Next.js Setup

The second step in this guide will be the frontend setup with Next.js. First, scaffold your front-end project with this command.

1    npx create-next-app blogs-frontend

A blogs-frontend folder is created in your root directory. Navigate into the folder and run npm run dev to start the frontend server. You can view your frontend locally using http://localhost:3000.

Tailwind CSS setup

Install Tailwind CSS into your frontend with npm.

1    npm install -D tailwindcss@latest postcss@latest autoprefixer@latest

Then, generate tailwind CSS configuration files.

1    npx tailwindcss init -p

This command will generate a postcss.config.js and a tailwind.config.js file to the root directory of your project. We will use these two files for any configurations relating to tailwind CSS in our project.

Finally, to complete the tailwind CSS setup, navigate to the pages/app.js file and replace import '../styles/globals.css' with import 'tailwindcss/tailwind.css'. You can delete the styles folder since we will not be using any custom CSS for our blog.

Markdown-to-jsx installation

Install markdown-to-jsx into your frontend use the following command -

1    npm install markdown-to-jsx

Markdown-to-jsx will be used to convert the markdown files obtained from Strapi into JSX files to be rendered in our frontend framework.

Connecting frontend to backend

To connect our Next.js frontend app to our backend, we will create a helper function that will make API calls to the Strapi backend with the fetch API.

Create the helper function, create a lib folder in your frontend folder root folder, and add a file named api.js to the lib folder.

Add the following code line to the api.js file.

1    export function getStrapiURL(path = "") {
2     return ${
3       process.env.NEXT_PUBLIC_STRAPI_API_URL || "http://localhost:1337"
4     }${path};
5    }
6    
7    // Helper to make GET requests to Strapi
8    export async function fetchAPI(path) {
9     const requestUrl = getStrapiURL(path);
10     const response = await fetch(requestUrl);
11     const data = await response.json();
12     return data;
13    }

What this code does is that it sends a get request to Strapi URL with the fetch API. Since we are only building a blog, a helper to fetch GET requests is enough for our project.

Designing the blog layout

We have our front and backend connected, plus tailwind CSS fully installed. The next step will be to create a layout for our blog.

Firstly, create a components folder in the root folder and add a Layout.js file into the folder. Next, add the following code into the components/layout.js file.

1    import Header from './header';
2    import Footer from './footer';
3    
4    const Layout = ({ children }) => (
5    <>
6      <Header />
7      {children}
8      <Footer />
9    </>
10    );
11    
12    export default Layout;

Then, we will create our header and footer files. First, add a header.js and a footer.js file to the component folder.

Add the following code to your header.js file

1   import React from "react";
2   import Link from "next/link";
3   
4   const Header = () => {
5    return (
6      <div>
7        <nav className="flex justify-center items-center h-16 py-2 mb-2 bg-gray-100 w-full border-b">
8        <div>
9          <Link href="/">
10            <a href="/" className="px-2 font-black lg:px-0 text-lg">
11               Sheriff's Blog
12              </a>
13           </Link>
14          </div>
15        </nav>
16      </div>
17    );
18   };
19   
20   export default Header;

Then, add the following code to the footer.js file.

1    import React from "react";
2    
3    const Footer = () => {
4     return (
5      <footer className="border-t mt-10 pt-12 pb-32 px-4 lg:px-0">
6         <div className="px-4 pt-3 pb-4 border-b -mx-4 border-gray-400">
7             <div className="max-w-xl mx-auto">
8                  <h2 className="text-xl text-left inline-block font-semibold text-gray-800">Join Our Newsletter</h2>
9                  <p className="text-gray-700 text-xs pl-px">
10                       Latest news ,articles and updates montly delevered to your inbox.
11                   </p>
12                   <form action="#" className="mt-2">
13                      <div className="flex items-center">
14                           <input type="email" className="w-full py-4 mr-2  bg-gray-100 shadow-inner rounded-md border border-gray-400 focus:outline-none" required />
15                          <button className="bg-blue-600 text-gray-200 text-sm rounded">Sign Up</button>
16                      </div>
17                  </form>
18              </div>
19           </div>
20       </footer>
21     );
22    };

1export default Footer;

The layout component will be wrapped around our page code to give our blog a uniform header and footer.

Designing the Home page

Move to your **index.js** file and discard the pre-existing code there. Then add the following lines of code to the **index.js** file.

1    import Link from "next/link";
2    import Layout from "../components/layout";
3    import { fetchAPI } from "../lib/api";
4    
5    export default function Home({ articles }) {
6     return (
7       <>
8         <Layout>
9          <body className="antialiased md:bg-gray-100">
10            <div className="grid grid-cols-1 md:grid-cols-3 gap-3">
11               {articles.map((article) => (
12                 <div key={article.id} className="md:p-8 p-2 bg-white">
13                   <div>
14                     {article.image && (
15                      <img src={`http://localhost:1337${article.image.url}`} />
16                     )}
17                   </div>
18                   {article.title}
19                   <div>
20                     {article.category && (
21                      <p className="text-indigo-500 font-semibold text-base mt-2">
22                         {article.category.name}
23                      </p>
24                    )}
25                   </div>
26                   <h1 className="font-semibold text-gray-900 leading-none text-xl mt-1 capitalize truncate">
27                    {article.title}
28                  </h1>
29                   <Link href={`/article/${article.slug}`}>
30                     <div className="max-w-full">
31                       <p className="text-base font-medium tracking-wide text-gray-600 mt-1">
32                         {article.description}
33                       </p>
34                     </div>
35                   </Link>
36                   <div className="flex items-center space-x-2 mt-20">
37                     <div>
38                       {article.author && (
39                        <p className="text-gray-900 font-semibold pb-2">
40                           {article.author.name}
41                         </p>
42                       )}
43                       <p className="text-gray-500 font-semibold text-sm">
44                         Created on - {new Date(article.created_at).toDateString()}
45                       </p>
46                       <p className="text-gray-500 font-semibold text-sm">
47                         Updated on - {new Date(article.updated_at).toDateString()}
48                       </p>
49                     </div>
50                   </div>
51                 </div>
52               ))}
53             </div>
54           </body>
55         </Layout>
56       </>
57     );
58    }
59    
60    export async function getStaticProps() {
61     try {
62       const articles = await fetchAPI("/articles?status=published");;
63       return {
64         props: {
65           articles
66         },
67       };
68     } catch (error) {
69       return { error };
70     }
71    }

In this code, we exported articles with the published Status from the Strapi backend with getStaticProps(). The getStaticProps() is a Next.js API that will pre-render our page at build time using the props returned in it.

We then pass the props(articles) returned by getStaticProps() into the <Home /> component. The props are then rendered in a UI built with Tailwind CSS. We will also wrap the page in the <Layout /> component to access our pre-made header and footer components.

The homepage should appear similar to this

Designing the blog post page

In this step, we will design a dynamic route to render each blog post page based on their slug. Thus, the URL of each page will be dependent on the slug of the page.

Create an article folder in the pages folder, and add a [slug].js file to the pages/article folder. Add the following lines of code to the pages/article/[slug].js file.

1    import Markdown from "markdown-to-jsx";
2    import { fetchAPI } from "../../lib/api";
3    import Layout from "../../components/layout";
4    
5    const Article = ({ article }) => {
6     return (
7       <>
8         <Layout>
9           <div className="mt-10">
10             <div className="mb-4 md:mb-0 w-full max-w-screen-md mx-auto">
11               <div className="absolute left-0 bottom-0 w-full h-full" />
12              <div>
13                 {article.image && (
14                  <img src={`http://localhost:1337${article.image.url}`} />
15                )}
16               </div>
17               <div>
18                 {article.category && (
19                   <a
20                     href="#"
21                     className="px-4 py-1 bg-black text-blue-200 inline-flex text-md items-center justify-center mb-2"
22                   >
23                     {article.category.name}
24                   </a>
25                 )}
26               </div>
27               <h2 className="text-4xl pt-2 font-semibold text-gray-500 leading-tigh`t">
28                 {article.description}
29               </h2>
30              <div className="mt-3">
31                 {article.author && (
32                   <p className="text-blue-900 font-semibold pb-2">
33                    Written by - {article.author.name}
34                   </p>
35                )}
36               </div>
37             </div>
38             <article className="prose lg:prose-xl px-4 lg:px-0 mt-12 text-gray-700 max-w-screen-md mx-auto text-lg leading-relaxed">
39               <Markdown>{article.content}</Markdown>
40             </article>
41           </div>
42         </Layout>
43       </>
44     );
45    };
46    
47    export default Article;
48    
49    export async function getStaticPaths() {
50     const articles = await fetchAPI("/articles");
51    
52     return {
53       paths: articles.map((article) => ({
54         params: {
55          slug: article.slug,
56        },
57       })),
58       fallback: false,
59     };
60    }
61    
62    export async function getStaticProps({ params }) {
63     const article = await fetchAPI(/articles/${params.slug}`);
64    
65     return {
66       props: { article },
67       revalidate: 1,
68     };
69    }

What this page does is that it gets a single article with its slug and displays the article. So, first, we query our backend for every article with the getStaticPaths() API. Then, we get the slug and store them in the slug params.

The slug params are then passed into the getStaticProps() API. The getStaticProps queries the backend with a single slug and returns the data collected from the backend as props. The props data are then passed into the < Article /> component and rendered with our UI created with tailwind CSS.

Each blog post should appear similar to this -

Now that our blog is completely designed, we can now configure the preview API for a more effortless content editing experience on our platform.

Activating the Preview mode

The first step will be to create a preview secret. Then, we will use this secret to access the preview mode securely in our browser.

Create a .env file and add your preview secret to the file PREVIEW_SECRET=****

Next, we will add a helper function to our /lib/api.js file. We will use this helper to query our backend for preview data.

1    export async function getPageData(slug, preview = false) {
2     // Find the pages that match this slug
3     const pagesData = await fetchAPI(
4       `/articles?slug=${slug}&status=published${preview ? "&status=draft" : ''}`
5     );
6    
7     // Make sure we found something, otherwise return null
8     if (pagesData == null || pagesData.length === 0) {
9       return null;
10     }
11    
12     // Return the first item since there should only be one result per slug
13     return pagesData[0];
14    }

The code queries the Strapi for the requested slug and returns both published or draft blog posts. The next step will be to create and configure the preview API route. In /pages/API, add a new file called preview.js. Then, add the following code to the file.

1    import { getPageData } from "../../lib/api"
2    
3    export default async function handler(req, res) {
4     if (req.query.secret !== (process.env.PREVIEW_SECRET || 'secret-token')) {
5       return res.status(401).json({ message: "Invalid token" });
6     }
7    
8     const pageData = await getPageData(req.query.slug, true);
9    
10     if (!pageData) {
11       return res.status(401).json({ message: "Invalid slug" });
12     }
13    
14     res.setPreviewData({});
15    
16     res.writeHead(307, { Location: `/article/${req.query.slug}` });
17     res.end();
18    };

What this code does is that it matches the secret in the preview URL to the preview secret in the .env file. After verifying the preview request, the API activates the preview mode and redirects to the article location.

When the preview mode is activated, Next.js sets some cookies in your browser. We will add these cookies to any request going to Next.js automatically, and Next.js treats any request with this cookie as a preview mode request.

Go back to your **[slug].js** file, import the getPageData helper from the **lib/api** page.

import { fetchAPI, getPageData } from "../../lib/api";

Change your getStaticProps() code to the following lines of code

1    export async function getStaticProps({ params, preview = null }) {
2    const article = await getPageData(params.slug, preview);
3   
4    return {
5      props: { article, preview },
6      revalidate: 1,
7    };
8   } 

Accessing the preview mode

Access the preview mode by navigating to this URL http://localhost:3000/api/preview?secret=&slug=

Where:

= secret token defined in your .env file = the draft page slug.

Deactivating the Previews mode

Navigate to the **pages/API** folder and add a new file named **exit-preview.js**. Next, add the following lines of code to the **exit-preview.js** file.

1    export default function handler(req, res) {
2    
3     try {
4       // Clears the preview mode cookies.
5       // This function accepts no arguments.
6       res.clearPreviewData()
7    
8       return res.status(200).json({ message: 'Cookies Cleared' })
9     } catch (error) {
10       return res.status(500).json({ message: error })
11     }
12    }

This code clears all the cookies set by the previews mode API in your browser. Also, Navigate to pages/articles/[slug].js and change the <Article /> component to this -

1    const Article = ({ article, preview }) => {
2     return (
3       <>
4         <div>
5           {preview ? (
6             <div className="relative bg-indigo-600">
7               <div className="max-w-7xl mx-auto py-3 px-3 sm:px-6 lg:px-8">
8                 <div className="pr-16 sm:text-center sm:px-16">
9                   <p className="font-medium text-white">
10                     <span>Preview mode is on,</span>
11                    <span className="block sm:ml-2 sm:inline-block">
12                      <a
13                       href="/api/exit-preview"
14                        className="underline hover:text-cyan transition-colors"
15                       >
16                         turn off
17                       </a>
18                     </span>
19                   </p>
20                 </div>
21               </div>
22             </div>
23           ) : null}
24         </div>
25         <Layout>
26           <div className="mt-10">
27             <div className="mb-4 md:mb-0 w-full max-w-screen-md mx-auto">
28              <div className="absolute left-0 bottom-0 w-full h-full" />
29              <div>
30                 {article.image && (
31                   <img src={`http://localhost:1337${article.image.url}`} />
32                 )}
33               </div>
34               <div>
35                 {article.category && (
36                   <a
37                     href="#"
38                     className="px-4 py-1 bg-black text-blue-200 inline-flex text-md items-center justify-center mb-2"
39                   >
40                     {article.category.name}
41                  </a>
42                )}
43               </div>
44               <h2 className="text-4xl pt-2 font-semibold text-gray-500 leading-tight">
45                 {article.description}
46               </h2>
47               <div className="mt-3">
48                 {article.author && (
49                   <p className="text-blue-900 font-semibold pb-2">
50                     Written by - {article.author.name}
51                   </p>
52                 )}
53               </div>
54             </div>
55             <article className="prose lg:prose-xl px-4 lg:px-0 mt-12 text-gray-700 max-w-screen-md mx-auto text-lg leading-relaxed">
56               <Markdown>{article.content}</Markdown>
57             </article>
58           </div>
59         </Layout>
60       </>
61     );
62    };

The blog post pages should look like this when preview mode is activated.

Click turn off to deactivate the preview mode. You can also deactivate the preview mode by navigating to http://localhost:3000/api/exit-preview.

Conclusion

The preview mode is an essential Static site generator tool that can improve the content editor experience using the Jamstack architecture.

To learn more about Next.js preview mode.

Source Code

This article is a guest post by Quadri Sheriff. He wrote this blog post through the Write for the Community program.