Published on

Next.js Commerce.js Static Site Generation

Authors
Table of Contents

Overview

The goal of this workshop is to walk you through on creating a simple commerce Jamstack application with a product listing page, product detail pages, and add to cart functionality using the Commerce.js SDK and Next.js. We will wrap up the workshop by deploying the application to Vercel. Throughout this workshop you will learn how to:

  1. Set up a Next.js project
  2. Install the Commerce.js SDK
  3. Fetch data from the Chec API using Commerce.js
  4. Create a product listing page
  5. Create static detail pages and use dynamic routing to the pages
  6. Deploy application to Vercel

See live demo

Workshop format

In this workshop, we will be focusing our efforts in integrating a commerce layer using the Chec API and Commerce.js SDK in a Next.js application. While we will also touch on Next.js concepts and high level of what a Jamstack is, we will stay focused on using Commerce.js.

Setting up a Next.js project is quite seamless but because most configurations have been set up along with predefined styles to make this workshop as valuable as possible, you will be cloning a GitHub repository and building from a start branch. Each section has a branch name associated with it so that you can checkout a branch if you'd like to see the next section ie. git checkout feature/add-plp.

Requirements

What you will need to start this project:

  • An IDE or code editor
  • Node.js >= 10
  • npm or yarn
  • React devtools (recommended)
  • GitHub account
  • Vercel account (recommended)

Prerequisites

This workshop assumes you have some knowledge of the below concepts before starting:

  • Basic knowledge of JavaScript
  • Some knowledge of React as Next.js is a fullstack framework built on top of React
  • An idea of the Jamstack architecture and how APIs work

Some things to note:

  • We will only cover high level concepts of React and Next.js.
  • To ensure you have some product data to work with for this workshop, we will provide you with a demo merchant public key.
  • We will not be going over account or dashboard setup. Have a read here if you'd like to learn more about setting up a Chec account.
  • This application is using the CSS utility library TailwindCSS, CSS preprocessor SASS, and BEM style naming methology for styling. Because the main goal of this guide is to learn build a Commerce.js and Next.js application, we will not be going over any styling details.

Initial setup

If you were to build a Next.js project from scratch, the simplest and quickest way to get started with a Next.js project is to run: create next-app command.

npx create-next-app
# or
yarn create next-app

Alternatively, if you don't want all the boilerplate code included you can run the following command in a new directory:

npm i react react-dom next
# or
yarn add react react-dom next

1. Install Commerce.js and add Next.js scripts to the repository

As noted above, let's clone the starter project from this repository, change directory into the project and install necessary dependencies.

git clone https://github.com/jaepass/commercejs-nextjs.git
# and
cd commercejs-nextjs && yarn

In order to communicate with the Chec API and fetch data from the backend, install the Commerce.js SDK:

yarn add @chec/commerce.js
# OR
npm install @chec/commerce.js

Next, you need to add some scripts to the package.json.

"scripts": {
  "dev": "next",
  "build": "next build",
  "start": "next start"
}
  • next starts Next.js in dev mode with hot reloading.
  • next builds your project and ready it for production.
  • next start starts your built app, used in production.

2. Store the public key in an environment variable file

Replace the sample .env.example dotenv file at the root of the project to store the Chec public_key.

# Copy from source file to destination file .env
cp .env.example .env

Open up your the .env file and add your Chec public key:

# Public key from Chec's demo merchant account
NEXT_APP_CHEC_PUBLIC_KEY=pk_184625ed86f36703d7d233bcf6d519a4f9398f20048ec

3. Create a Commerce.js instance

The Commerce.js SDK comes packed with all the frontend oriented functionality to get a customer-facing web-store up and running. To use the SDK, import the module in a folder called lib so you have access to the Commerce object instance throughout your application.

Go ahead and do that right now! In your src directory, create a new folder called lib, create a file commerce.js and copy and paste the below code in it. A lib folder in a project typically stores files that abstracts functions or some form of data.

// src/lib/commerce.js

import Commerce from '@chec/commerce.js'

const checPublicKey = process.env.NEXT_PUBLIC_CHEC_PUBLIC_KEY
const devEnvironment = process.env.NODE_ENV === 'development'

if (devEnvironment && !checPublicKey) {
  throw Error(
    'A Chec public API key must be provided as an environment variable named NEXT_PUBLIC_CHEC_PUBLIC_KEY. Retrieve your Chec public key in your Chec Dashboard account by navigating to Setup > Developer, or can be obtained with the Chec CLI via with the command chec whoami'
  )
}

export default new Commerce(checPublicKey, devEnvironment)

Above, you've imported the Commerce object, then exported the instance with your Chec API key provided via an environment variable. The public key is needed to give you access to data via the Chec API.

You might want to throw an error if the public key isn't available, since it will probably make your application unusable.

Now, let's start your dev server.

yarn dev
# OR
npm dev

In this section, you will make your first request to the Chec API using Commerce.js and build out the product listing page.

Create an index page

First create the directory /pages with index.js in it and type in the following:

const Index = () => <div>Hello</div>

export default Index

Next.js comes with built-in page based and file system routing so any file in the pages directory is associated as a route. The file name computes to the route name. We will be creating dynamic routes in the next section but for now let's continue on with getting some data from the Chec API.

Fetch data from the Chec API

Commerce.js was built with all the frontend functionality needed to build a complete and custom eCommerce store. Simply make requests to various Chec API endpoints, receive successful responses, then use the raw data to output beautifully onto your web store.

Let's start to make requests to fetch data from Chec to list the merchant details and product data. Continuing from index.js, you need to first import in the commerce client created in lib then use the getStaticProps function in Next.js to store fetch and return our props. The two requests we will make are:

  • Make a request to the merchant API endpoint and fetch the merchant's information using the Commerce.js merchant.about method. This function returns the merchant object with details such as the name and contact info.
  • Make a request to the products API endpoint using the Commerce.js products.list method to fetch the products data. The request will return an array of product objects with properties such the products' names, prices, and description.

After the request statements, return both merchant and products and props. With the props now available, create the Index function, pass in both props and let's just render out the data in JSON to take a look at what gets returned!

import { commerce } from '../lib/commerce'

export async function getStaticProps() {
  const merchant = await commerce.merchants.about()
  const { data: products } = await commerce.products.list()

  return {
    props: {
      merchant,
      products,
    },
  }
}

const Index = ({ merchant, products }) => (
  <div>
    <h1>Merchant</h1>
    <pre>{JSON.stringify(merchant, null, 2)}</pre>
    <h1>Products</h1>
    <pre>{JSON.stringify(products, null, 2)}</pre>
  </div>
)

export default Index

With the product data you will be able to use the various product properties such as product.name to render a product item component, which you'll get to building in the next section.

Create a product item component

The nature of modern frameworks is to separate your code into components. Components are a way to encapsulate a group of elements for reuse throughout your application. You'll be creating two components for the product listing page, one will be for the single product item and another to render out the list of products.

Start by creating a function component and name it ProductItem.js in a new directory components. This component will render the individual product card. Pass in a product prop as the parameter. You will reference this property to access each product's image and name via product.media.source and product.name.

import ArrowRight from '../assets/arrow-right.svg'

const ProductItem = ({ product }) => {
  return (
    <div className="product">
      <img className="product__image" src={product.media.source} alt={product.name} />
      <div className="product__info">
        <h2 className="product__name">Shop {product.name}</h2>
        <ArrowRight className="product__icon" width={48} height={48} />
      </div>
    </div>
  )
}

export default ProductItem

With our ProductItem component, let's now get to creating a product listing component to render out a list of the product item cards in the next section.

Create a product listing page

It's now time to create a ProductsList.js component inside /components. The ProductsList component will be function component which will loop through and render a list of ProductItem components.

First, import the next/link module and the ProductItem component. Next, define a products prop. This will be provided by the parent component. You need to then use map through the products data array to render a ProductItem component for each product in your products prop. When a looping method is used to render out an array list, a unique identifier needs to be used (product.id) as the key attribute in the Link component - React will use it to determine which items in a list have changed and which parts of your application need to be re-rendered. The Link component wraps around each ProductItem to navigate to a single product detail page using the permalink property, you will be building this page view in the next section.

import Link from 'next/link'
import ProductItem from './ProductItem'

const ProductListing = ({ products }) => (
  <div className="products" id="products">
    {products.map((product) => (
      <Link href={`/product/${product.permalink}`} key={product.id}>
        <a>
          <ProductItem product={product} />
        </a>
      </Link>
    ))}
  </div>
)

export default ProductListing

Render the product listing page

With both your product item and list components created, let's get back to your Index.js to render the <ProductListing /> and pass in the products prop with the returned product data as the value.

import { commerce } from '../lib/commerce'
import Header from '../components/Header'
import Hero from '../components/Hero'
import ProductListing from '../components/ProductListing'

export async function getStaticProps() {
  const merchant = await commerce.merchants.about()
  const { data: products } = await commerce.products.list()

  return {
    props: {
      merchant,
      products,
    },
  }
}

const Index = ({ merchant, products }) => (
  <div>
    <Header merchant={merchant} />
    <Hero />
    <ProductListing products={products} />
  </div>
)

export default Index

In this section, you will get to creating a single product detail page.

Create dynamic routes with getStaticPaths

First, view the index page in the browser and click one of the product items, you will notice that you are navigated to a 404 page. Next.js is automatically doing that for us if we try to route to a page that does not exist. Now let's fix that and create some dynamic routes and static pages.

As you notice in our product listing, we are using next/link to handle client-side navigation to the dynamic routes we will create. Commerce.js allows us to work with various properties in the products endpoint such as the description and other meta data so we will be using some of the properties to output in a dynamically routed page. Now create [permalink].js in a new directory product/ - pages/product/[permalink].js

import { useRouter } from 'next/router'
import { commerce } from '../../lib/commerce'
import Link from 'next/link'
import ArrowLeft from '../../assets/arrow-left.svg'
import ArrowRight from '../../assets/arrow-right.svg'

export async function getStaticPaths() {
  const { data: products } = await commerce.products.list()

  return {
    paths: products.map((product) => ({
      params: {
        permalink: product.permalink,
      },
    })),
    // We'll pre-render only these paths at build time.
    // { fallback: false } means other routes should 404.
    fallback: false,
  }
}

export async function getStaticProps({ params }) {
  const { permalink } = params
  // Call the Chec API endpoint to get products.
  // Retrieve product by permalink
  const product = await commerce.products.retrieve(permalink, {
    // Must include a type value
    type: 'permalink',
  })

  return {
    props: {
      product,
    },
    revalidate: 60,
  }
}

const ProductDetailPage = ({ product }) => {
  return (
    // Add head tag
    <div className="product-detail">
      <img className="product-detail__image" src={product.media.source} alt={product.name} />
      <div className="product-detail__info">
        <Link href="/">
          <a className="product-detail__back">
            <ArrowLeft className="product__icon" width={42} height={42} />
            <p>Back to products</p>
          </a>
        </Link>
        <div className="product-detail__details">
          <h1 className="product-detail__name">{product.name}</h1>
          <div
            className="product-detail__description"
            dangerouslySetInnerHTML={{ __html: product.description }}
          ></div>
          <div className="product-detail__price">{product.price.formatted_with_symbol}</div>
        </div>
      </div>
      <button name="View item" className="product-detail__btn">
        <span>Add to cart</span>
        <ArrowRight className="product__icon" width={48} height={48} />
      </button>
    </div>
  )
}

export default ProductDetailPage

Product descriptions in the Chec API return HTML to prevent cross-site scripting. Because data coming from the Chec API is a trusted source, we can use the built-in React dangerouslySetTo strip HTML from the product description string, using [this string-strip-html](https://codsen.com/os/string-strip-html/) handy library will do the trick. Install this library by running yarn add string-strip-htmlornpm i string-strip-html. After installing, import the module in and pass in the product description to the stripHtml` function.