If you've been working in web accessibility for a while, you know there are many foundational quick-wins that can go a long way. If you're new to web accessibility, hopefully this doesn't come as a surprise! There are definitely challenging aspects to web accessibility, but it's not all that way. And lucky for us, a lot of the quick-wins are also quick and easy to identify with some automated tools! [`pa11y-ci`](https://github.com/pa11y/pa11y-ci) is just one of those tools.

In this post, I'll show you how I set up a [GitHub Action](https://github.com/features/actions) that runs `pa11y-ci` as a pull request check. The check will run against a Vercel deploy preview, and then the results will be shared as a comment on the pull request for easy visibility.

If at any point you find yourself stuck or needing to troubleshoot, check out a GitHub repository I created that represents the end-result of this guide: https://github.com/ashleemboyer/pa11y-ci-test-app.

## Step 1 (optional): Create a Next.js App

If you don't already have a Next.js App to follow along with, I recommend creating one. There are multiple ways of doing this detailed on [the Next.js Getting Started page](https://nextjs.org/docs/getting-started). To keep things simple for this example, I'm using the Automatic Setup approach.

**To create the Next.js app:**

1. Open a terminal
2. Run `npx create-next-app@latest`
3. When prompted, name the app `pa11y-ci-test-app`
4. Change directory into the new folder: `cd pa11y-ci-test-app`
5. Briefly explore the code and learn your way around

Note: I will be using `npm` instead of `yarn` for the rest of this post. If your generated project uses `yarn`, and you would also like to to use `npm` instead:

1. Run `rm yarn.lock` to delete the file
2. Run `npm install` to create a `package-lock.json` file
3. Run `npm run build` so the `package-lock.json` file can be patched if needed
4. Run `npm install` one more time to download any missing dependencies
5. Run `git add .` to stage the changed files for a commit
6. Run `git commit -m "Using npm instead of yarn"` to commit the changes

## Step 2 (optional): Create and Connect a GitHub Repository

If you followed step 1 and created a new Next.js App, you should follow this step as well. You will need a GitHub Repository for your project in order to run the GitHub Action we're creating.

**To create the GitHub Repository:**

1. Go to [github.com/new](https://github.com/new)
2. If needed, log in to your account
3. Under "Owner", select your account
4. Under "Repository name", enter `pa11y-ci-test-app`
5. Select either "Public" or "Private"
6. Click the "Create repository" button
7. Leave this page open in your browser

**To connect the GitHub Repository to your project:**

1. In a terminal, go to your project folder
2. Run `git remote add origin git@github.com:<YOUR-USERNAME>/pa11y-ci-test-app.git` after replacing `<YOUR-USERNAME>` with the GitHub username you used to create the repository. (Read about [Working with Remotes](https://git-scm.com/book/en/v2/Git-Basics-Working-with-Remotes) and [Remote Branches](https://git-scm.com/book/en/v2/Git-Branching-Remote-Branches) if you're curious.)
3. Run `git push -u origin main` to push the code to the repository.
4. Verify these steps were successful by refreshing your new repository's page in your browser

## Step 3: Install and Configure `pa11y-ci`

It's always good to test new tools locally (on your machine) before testing them remotely in a place like a pull request. Testing remotely can be tedious and time consuming, and the results of the testing can also be more difficult to locate and read. And if you happen to be like me and have ADHD, all of that is a recipe for multiple distractions!

Before doing anything else, let's create a new git branch. That will be useful later when we need to create a pull request for our GitHub Action.

**To create a new `git` branch:**

1. In a terminal, go to your project folder
2. Run `git checkout -b add-pa11y-ci`

**To install `pa11y-ci`:**

1. In a terminal, go to your project folder
2. Run `npm install --save-dev pa11y-ci`
3. Open the `package.json` file in your project
4. Verify the `pa11y-ci` package is listed under `devDependencies`

**To configure `pa11y-ci` for local testing:**

1. In your project folder, create a file called `.pa11yci`
2. In the new file, paste the following JSON:

```json
{
  "urls": ["http://localhost:3000/"]
}
```

This configuration tells `pa11y-ci` exactly what `urls` in our app it needs to test.

## Step 4: Test `pa11y-ci` locally (on your machine)

Now that we have `pa11y-ci` installed and configured for local testing, we can get to testing!

1. In your project folder, open the `package.json` file
2. Under the `"scripts"` property, add a new entry: `"pa11y-ci": "pa11y-ci"`
3. Open two separate terminals to your project folder
4. In the first terminal, run `npm run dev` to start the app
5. In the second terminal, run `npm run pa11y-ci` to run the new script we added in step 2

After `pa11y-ci` has finished running, this is how the output should read:

```
> pa11y-ci-test-app@0.1.0 pa11y-ci
> pa11y-ci

Running Pa11y on 1 URLs:
 > http://localhost:3000/ - 1 errors

Errors in http://localhost:3000/:

 • The html element should have a lang or xml:lang attribute which describes the language of the document.

   (html)

   <html><head><meta name="viewport" con...</html>

✘ 0/1 URLs passed
```

Hooray! We have an error, but the good news is that means `pa11y-ci` is working! Now we can progress from local testing towards creating our GitHub Action.

## Step 5: Deploy to Vercel

Our current configuration for `pa11y-ci` only works for when we run our app locally with `npm run dev`. For remote testing, we want `pa11y-ci` to test against real builds and public-facing urls. In order to do that, we need to deploy our Next.js app. We'll use Vercel in this example.

**How to deploy to Vercel:**

1. Go to [vercel.com/new](https://vercel.com/new)
2. If needed, log in to your account
3. Under "Import Git Repository", select "Continue with GitHub"
4. Search for your new repo (mine is called `pa11y-ci-test-app`)
5. Click the Import button in-line with the repo name
6. Click the Deploy button (you should not need to change any configuration)

Once the deploy is complete, you can close this window.

## Step 6: Install and Configure `next-sitemap`

There's another way `pa11y-ci` can be used to test against urls, and that is with the `--sitemap` option. This option is nice when you have a `sitemap.xml` file on your site that updates every time a build occurs. It means you don't have to manually update the `.pa11yci` file's list of urls every time a new page is added. The tool we'll use for generating a `sitemap.xml` file is called [`next-sitemap`](https://www.npmjs.com/package/next-sitemap), which is the tool I use on my own website for `pa11y-ci` testing.

**To install `next-sitemap`:**

1. In a terminal, go to your project folder
2. Run `npm install next-sitemap`

**To configure `next-sitemap`:**

1. In your project folder, create a new file called `next-sitemap.config.js`
2. In the new file, paste the following JavaScript:

```javascript
module.exports = {
  siteUrl: process.env.VERCEL_URL
    ? `https://${process.env.VERCEL_URL}`
    : 'http://localhost:3000/',
};
```

This tells `next-sitemap` what the main url of your site is. If you use a different port number than `3000`, make sure to update the code above to match the port number you use.

## Step 7: Test `next-sitemap` locally (on your machine)

To make sure we have everything configured correctly, we're going to test `next-sitemap` locally just like we did with `pa11y-ci`.

1. In your project folder, open the `package.json` file
2. Under the `"scripts"` property, add a new entry: `"postbuild": "next-sitemap"`
3. In a terminal, go to your project folder
4. Run `npm run build`

The new `postbuild` script we added will run automatically after the `build` script has completed. You should see some new `sitemap` files in the `public` directory. We will add those to the `.gitignore` file in the next section.

You should also see something like this output in the terminal after the `build` script output:

```
> pa11y-ci-test-app@0.1.0 postbuild
> next-sitemap

✨ [next-sitemap] Loading next-sitemap config: file:///pa11y-ci-test-app/next-sitemap.config.js
✅ [next-sitemap] Generation completed
┌───────────────┬────────┐
│    (index)    │ Values │
├───────────────┼────────┤
│ indexSitemaps │   1    │
│   sitemaps    │   1    │
└───────────────┴────────┘
-----------------------------------------------------
 SITEMAP INDICES
-----------------------------------------------------

   ○ http://localhost:3000/sitemap.xml


-----------------------------------------------------
 SITEMAPS
-----------------------------------------------------

   ○ http://localhost:3000/sitemap-0.xml
```

## Step 8: Prepare for and Create a New Pull Request

Hopefully you created a new git branch called `add-pa11y-ci` [in Step 3](#step-3-install-and-configure-pa11y-ci), but it's also okay if you didn't! Go ahead and create it now. We'll need a different branch off of the main one in order to create a pull request in our GitHub repository.

**To prepare for the pull request:**

1. Make sure there is a `/public/sitemap*` entry in the `.gitignore` file. We **do not** want to commit these files since they need to be generated by the Vercel build process.
2. Make sure you have all your new `pa11y-ci` and `next-sitemap` work committed. I'm committing everything at once with the message: `"Adding pa11y-ci and next-sitemap"`.
3. Run `git push --set-upstream origin add-pa11y-ci` to push your new branch up to the repository.

**To create the new pull request:**

1. Go to `github.com/<YOUR-USERNAME>/pa11y-ci-test-app/compare` after replacing `<YOUR-USERNAME>` with the GitHub username you used to create the repository
2. Change the `compare` branch to `add-pa11y-ci`
3. The page should update have at least these 5 changed files:
   - `.gitignore`
   - `.pa11yci`
   - `next-sitemap.config.js`
   - `package-lock.json`
   - `package.json`
4. Click the "Create pull request" button
5. You should see 2 text boxes: one for the name of the pull request and one for the description
6. Fill in the title and description however you need
7. Click "Create pull request"

**To verify everything is set up correctly:**

1. Wait for the `vercel` bot to comment on the new pull request
2. In the new comment, open the "Visit Preview" link in a new tab
3. You should see your app built and running
4. Go to the `/sitemap.xml` page in the same app
5. You should see an XML file with contents that look something like this:

```xml
<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  <sitemap>
    <loc>YOUR-APP-URL/sitemap-0.xml</loc>
  </sitemap>
</sitemapindex>
```

## Step 9: Create the pa11y-ci GitHub Action

Now that we have a live website to have `pa11y-ci` test against, we can create the GitHub Action that runs `pa11y-ci`.

**To create the GitHub Action:**

1. In your project folder, create a new folder called `.github`
2. In the new `.github` folder, create another folder called `workflows`
3. In the new `workflows` folder, create a new file called `pa11y-ci.yml`
4. Paste the following content in your new file:

```yml
# Wait to run until after the Vercel deployment has finished
# https://docs.github.com/en/actions/using-workflows/events-that-trigger-workflows#deployment_status
on: deployment_status

jobs:
  pa11y-ci:
    # Only run if the Vercel deployment was successful
    # https://docs.github.com/en/developers/webhooks-and-events/webhooks/webhook-events-and-payloads#deployment_status
    if: github.event.deployment_status.state == 'success'
    runs-on: ubuntu-latest

    steps:
      # Checkout latest commit of repo
      # https://github.com/actions/checkout#checkout-v3
      - uses: actions/checkout@v3

      # Install project dependencies
      - run: npm install

      # Run pa11y-ci against the generated sitemap
      # https://github.com/pa11y/pa11y-ci#sitemaps
      - run: npm run pa11y-ci -- --sitemap ${{ github.event.deployment_status.target_url }}/sitemap.xml
```

Before committing and pushing this new file, make sure to delete the `.pa11yci` file. It's no longer needed.

**To verify the GitHub Action works:**

1. Commit and push the new `.github/workflows/pa11y-ci.yml` and the removed `.pa11yci` file
2. Go to your pull request in a browser
3. Towards the bottom of the page, wait until you see the `pa11y-ci` check finish
4. The check should fail
5. Click the "Details" link to inspect the failed check
6. You should see the same error that you saw when testing locally in [Step 4](#step-4-test-pa11y-ci-locally-on-your-machine)

## Step 10 (optional): Update the pa11y-ci GitHub Action to add a comment on pull requests

When I added this `pa11y-ci` GitHub Action to my own site's pull requests, I decided to make it also comment results on the pull request. There are a couple of reasons for this:

- Normally you have to click the "Details" link next to a failed pull request check. This takes you to another page and away from the pull request. For me, that means an opportunity to get easily distracted.
- The formatting of results in pull request checks can sometimes be difficult to read. Putting the results in a pull request comment gives an opportunity to re-format them in a more readable way.

So to update the GitHub Action to comment on pull requests, we'll need to tell the `pa11y-ci` command to output its results in a different way, and then we'll add a step to the GitHub Action that reads the output, formats it, and creates a comment.

1. Update the `pa11y-ci` `run` step in `.github/workflows/pa11y-ci.yml` to be:
   ```yml
   # Run pa11y-ci against the generated sitemap
   # https://github.com/pa11y/pa11y-ci#sitemaps
   - run: npm run pa11y-ci -- --json --sitemap ${{ github.event.deployment_status.target_url }}/sitemap.xml |& tee pa11y-output.txt
   ```
2. Add a new step at the end of the file like this:
   ```yml
   # Comment the formatted pa11y-ci results on the PR
   - uses: actions/github-script@v5
     env:
       BODY_PREFIX: ''
     with:
       script: |
         const script = require('./.github/workflows/scripts/pa11y-ci.js')
         await script({ context, core, github })
   ```
3. Add a new folder inside `.github/workflows` called `scripts`
4. Add a new file to `scripts` called `pa11y-ci.js`
5. In the new file, paste the following JavaScript:

   ````js
   const { promises: fs } = require('fs');

   module.exports = async ({ context, core, github }) => {
     // Find this PR & do nothing if this isn't a PR
     const { data } =
       await github.rest.repos.listPullRequestsAssociatedWithCommit({
         owner: context.repo.owner,
         repo: context.repo.repo,
         commit_sha: context.sha,
       });
     const prNumber = data[0] && data[0].number;
     if (!prNumber) {
       return;
     }

     // Read the pa11y output and build the comment body
     const pa11yOutput = await fs.readFile('./pa11y-output.txt', 'utf8');
     const lines = pa11yOutput.split('\n');
     const asJSON = JSON.parse(lines.find((line) => line.startsWith('{')));
     const { total, errors, results } = asJSON;

     let commentBody = `${process.env.BODY_PREFIX}\n<h2>:microscope: pa11y-ci results</h2>\n\n`;
     commentBody += `- Number of URLs tested: ${total}\n`;

     if (!errors) {
       commentBody += `- No errors were found! :tada:\n`;
     } else {
       commentBody += `- Number of errors found: ${errors}. :sob:\n`;

       let formattedOutput = '';
       Object.keys(results).forEach((urlKey) => {
         const errors = results[urlKey];
         if (errors.length < 1) {
           return;
         }

         formattedOutput += `- [${urlKey}](${urlKey}):\n\n`;
         errors.forEach((error) => {
           formattedOutput += '  ```\n';
           formattedOutput += `  ${error.message}\n\n`;
           formattedOutput += `  ${error.selector}\n\n`;
           formattedOutput += `  ${error.context}\n\n`;
           formattedOutput += `  ${error.code}\n`;
           formattedOutput += '  ```\n\n';
         });
       });

       commentBody += `<details><summary>See results :eyes:</summary>\n\n${formattedOutput}</details>`;
     }

     // Get the comments on this PR
     const { data: comments } = await github.rest.issues.listComments({
       owner: context.repo.owner,
       repo: context.repo.repo,
       issue_number: prNumber,
     });

     // Try to find an existing pa11y results comment
     const previousComment = comments.find((comment) =>
       comment.body.startsWith(process.env.BODY_PREFIX),
     );
     if (previousComment) {
       // Update the previous comment
       await github.rest.issues.updateComment({
         owner: context.repo.owner,
         repo: context.repo.repo,
         comment_id: previousComment.id,
         body: commentBody,
       });
     } else {
       // Create a new comment
       await github.rest.issues.createComment({
         owner: context.repo.owner,
         repo: context.repo.repo,
         issue_number: prNumber,
         body: commentBody,
       });
     }

     if (errors) {
       core.setFailed('Errors were found by pa11y-ci');
     }
   };
   ````

6. Commit and push the changes to `.github/workflows/pa11y-ci.yml` and the new `.github/workflows/scripts/pa11y-ci.js` file.

**To verify that everything is working as expected:**

1. Go to your pull request in your browser
2. Wait for the `pa11y-ci` check to finish
3. The check should fail just like it did before
4. Look for a comment by the `github-actions` bot that says "🔬 pa11y-ci results"
5. The comment should say that 1 error was found
6. Expand the "See results 👀" text
7. There should be one error listed that matches the same error you've been seeing

## Step 11. Celebrate! 🎉

Nicely done! You've added a `pa11y-ci` GitHub Action that runs on pull requests. You should be proud. Give yourself a pat on the back. 😊

Use pa11y-ci to test deploy previews before merging pull requests.

How I Added a pa11y-ci GitHub Action to My Next.js Site


I recently came across [a tweet from Sara Soueidan](https://twitter.com/SaraSoueidan/status/1390598514774847496) applauding folks who provide an RSS feed on their site. Sara is someone I highly admire in frontend web development and accessibility, but I had so little knowledge of RSS feeds and so many questions:

- What the heck are they?
- What are they for?
- I thought people didn't use them anymore?

If you also have questions like this, I recommend reading [How Do RSS Feeds Work?](https://rss.com/blog/how-do-rss-feeds-work/) right from RSS.com. The first few words really sum it up:

> Imagine being able to log into one dashboard and getting the latest news and events from all of your favorite websites, blogs, or podcasts? With RSS feeds, it’s possible!

To better understand how RSS feeds are consumed, I created my own RSS reader app and I also [wrote about it](https://ashleemboyer.com/create-your-own-nextjs-rss-reader-app) so you can create one too if you like. The app I created also served as a great way for me to test my RSS feed as I built it!

## How I Added an RSS Feed to my Next.js Site

There were two main problems I ran into while trying to build an RSS feed for my articles. Firstly, I didn't know that neither the `<description>` nor `content` of each `<item>` in the channel can't have regular HTML in it. [The HTML tags must be encoded](https://cyber.harvard.edu/rss/encodingDescriptions.html). Secondly, I found out it's really difficult to try to parse the HTML content in a Node.js environment on my own before putting it into the feed.

After struggling for hours and trying several different approaches, I [went to Twitter for help](https://twitter.com/AshleeMBoyer/status/1391568723581054978). There were a lot of helpful replies! I found exactly what I ended up using thanks to [an example project](https://github.com/sweeneyapps/html2rssfeed) from [@vphreak](https://twitter.com/vphreak/status/1391853784666501121). So, what did it take?

First, I installed [the `feed` package](https://github.com/jpmonette/feed).

```bash
yarn add feed
```

Then, I added a `generateRSSFeed` function.

```js
const generateRSSFeed = (articles) => {
  const baseUrl = 'https://ashleemboyer.com';
  const author = {
    name: 'Ashlee Boyer',
    email: 'hello@ashleemboyer.com',
    link: 'https://twitter.com/ashleemboyer',
  };

  // Construct a new Feed object
  const feed = new Feed({
    title: 'Articles by Ashlee M Boyer',
    description:
      "You can find me talking about issues surrounding Disability, Accessibility, and Mental Health on Twitter, or you can find me regularly live-knitting or live-coding on Twitch. I'm @AshleeMBoyer on all the platforms I use.",
    id: baseUrl,
    link: baseUrl,
    language: 'en',
    feedLinks: {
      rss2: `${baseUrl}/rss.xml`,
    },
    author,
  });

  // Add each article to the feed
  articles.forEach((post) => {
    const {
      content,
      fileName,
      meta: { date, description, title },
    } = post;
    const url = `${baseUrl}/${fileName}`;

    feed.addItem({
      title,
      id: url,
      link: url,
      description,
      content,
      author: [author],
      date: new Date(date),
    });
  });

  // Write the RSS output to a public file, making it
  // accessible at ashleemboyer.com/rss.xml
  fs.writeFileSync('public/rss.xml', feed.rss2());
};
```

Finally, I updated the `getStaticProps` function exported from `src/pages/index.jsx` to call the new `generateRSSFeed` function.

```js
export async function getStaticProps() {
  const articles = getAllArticles();
  articles.sort((a, b) => (a.meta.date < b.meta.date ? 1 : -1)

  generateRSSFeed(articles);

  return { props: { articles } };
}
```

Because my site is set up to build only when my main git branch is updated, `getStaticProps` will be called at that time and so will `generateRSSFeed`. This means the feed is always up to date when I push a new Markdown file for each post or whenever existing files are updated.

## Resources

- [RSS 2.0 Specification](https://validator.w3.org/feed/docs/rss2.html)
- [`feed` GitHub repository](https://github.com/jpmonette/feed#readme)
- [W3Schools XML RSS page](https://www.w3schools.com/xml/xml_rss.asp)


Learn how to add an RSS feed to your own Next.js site.

How I Added an RSS Feed to My Next.js Site


I recently came across [a tweet from Sara Soueidan](https://twitter.com/SaraSoueidan/status/1390598514774847496) applauding folks who provide an RSS feed on their site. Sara is someone I highly admire in frontend web development and accessibility, but I had so little knowledge of RSS feeds and so many questions:

- What the heck are they?
- What are they for?
- I thought people didn't use them anymore?

If you also have questions like this, I recommend reading [How Do RSS Feeds Work?](https://rss.com/blog/how-do-rss-feeds-work/) right from RSS.com. The first few words really sum it up:

> Imagine being able to log into one dashboard and getting the latest news and events from all of your favorite websites, blogs, or podcasts? With RSS feeds, it’s possible!

RSS feeds mean I can read all of my favorite blogs in one place?? And I don't _have_ to subscribe to newsletters to know when a new post has been published?? That sounds so lovely! I knew then that I definitely needed to figure out how to provide an RSS feed for my own site.

In order to better understand how to create an RSS feed for my site, I needed to better understand how they are used. This is where I got the idea to create my own RSS reader app! Once I had the app finished, it also doubled as a way for me to test my RSS feed as I developed it.

I had a ton of fun with it so I decided to share my findings with y'all in case you also want to make your own RSS reader app. I hope you find the instructions below helpful and as always, let me know on Twitter if you have any questions!

## How to Create Your Own Next.js RSS Reader App

### Fork and clone the repo

First, you need to create a fork of the starter code.

1. Go to [the GitHub repository](https://github.com/ashleemboyer/nextjs-rss-reader-starter)
2. Click the "Fork" button at the top right of the page
3. Follow the steps provided by GitHub

Second, clone the fork you've created onto your machine and install the dependencies.

```bash
git clone <your fork>    # Clones the fork
yarn                     # Installs the dependencies
```

### Set up Firebase Authentication

Third, you need to create a Firebase project since it'll handle authentication. You want this app to have authentication so that other people aren't driving up your API requests that will be made to RSS to JSON (we'll set that up next).

1. Go to [console.firebase.google.com](https://console.firebase.google.com) and make sure you're logged in with the Google account you want to use.
2. Click the card that says "Add project". It should be the first one listed.
3. Enter a project name. I'm going to use `nextjs-rss-reader`.
4. Toggle "Enable Google Analytics for this project" to off.
5. Click "Create project".
6. Click "Continue" when your new project is ready.

Here's a video showing these steps (the project name is different):

<iframe title="Create a New Firebase Project" width="100%" height="350" src="https://www.youtube-nocookie.com/embed/2w5BV9ft82g" frameBorder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowFullScreen></iframe>

Firebase makes it easy for us to set up email/password authentication in our app. It's also easy to add a user for ourselves right from the console. Make sure you use a real email address and a secure password for your user. This is how you're protecting your feed!

1. Go to [the Firebase console](console.firebase.google.com) for your project.
2. Go to the "Authentication" page under "Build".
3. Click "Get Started".
4. You should be on the "Sign-in method" tab.
5. Click "Email/Password".
6. Enable the first toggle.
7. Click "Save".
8. Switch to the "Users" tab.
9. Click "Add user".
10. Enter a secure email and password.
11. Click "Add user".

Here's a video showing these steps:

<iframe title="Set up Email/Password Firebase Authentication" width="100%" height="350" src="https://www.youtube-nocookie.com/embed/WTnIU0ZtCoo" frameBorder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowFullScreen></iframe>

### Create an RSS to JSON account

Next, let's set up an RSS to JSON account so we can get an API key for making API requests. I personally have a paid plan because of the number of feeds I subscribe to, but the free plan is pretty nice! At the time of this writing, the free plan updates a feed once an hour, allows 10,000 requests per day, and supports 25 feeds. The starter code is currently set up to generate your site no more than once per day, so at the very most, you'll be making 1 request per feed per day.

1. Sign up for an RSS to JSON account at [this link](https://rss2json.com/sign-up)
2. Get your API key from [the My Account page](https://rss2json.com/me/api_key) and have it ready for the next step.

### Create a .env file

In the root of your forked project, create a file called `.env`. It will have four items in it.

```env
RSS_2_JSON_API_KEY=<your RSS to JSON api key>
NEXT_PUBLIC_FIREBASE_API_KEY=<your Firebase project's API key>
NEXT_PUBLIC_FIREBASE_AUTH_DOMAIN=<your Firebase project's auth domain>
NEXT_PUBLIC_FIREBASE_PROJECT_ID=<your Firebase project ID>
```

Put your RSS to JSON API key from the previous step with the `RSS_2_JSON_API_KEY` item. You can get the other items from Firebase after registering your app. Here are the steps for that:

1. Go to [the Firebase console](https://console.firebase.google.com/) for your project
2. Go to the project settings
3. Scroll to the bottom of the page where it says "Your apps"
4. Click the `</>` button to register your app for web
5. For "App nickname", enter `nextjs-rss-reader`
6. Click the "Register app" button
7. Copy and paste the `apiKey`, `authDomain`, and `projectId` values with the last three items in your `.env` file

### Start the app

We're ready to go! Start the app with `yarn dev` and go to http://localhost:3000/ in your browser. You should be redirected to the login page where you can enter your email and password for the user you created in the second part of the Set up Firebase Authentication section above.

![Browser window screenshot with a background of large, dark green leaves. The window shows a white webpage showing "Log In" text at the top. There is an input for email and password and a gray "Sign In" button.](https://firebasestorage.googleapis.com/v0/b/ashleemboyer-2018.appspot.com/o/images%2F2021%2F05%2Fcreate-your-own-nextjs-rss-reader-app%2Flogin-page.png?alt=media&token=0ec4c0d0-6939-4858-a76d-31bd7d2f5010)

After logging in, you should see a list of articles. You can click the "Read here" links to read the article within your app, or you can click the "Read at source" link to read the original version of the article!

![Browser window screenshot with a background of large, dark green leaves. The window shows a white webpage with black text. The title is "My RSS Reader" and there is a vertical list of articles with thin black borders. Each article first shows the title in large bold text, then the name of the feed, author, and publish date on the next line, then a horizontal rule, and lastly the article's description as HTML.](https://firebasestorage.googleapis.com/v0/b/ashleemboyer-2018.appspot.com/o/images%2F2021%2F05%2Fcreate-your-own-nextjs-rss-reader-app%2Farticles-page.png?alt=media&token=81e422b0-addc-47fe-ae3d-539477222d39)

### Customize your feed

The app knows what feeds to fetch by the `feed.txt` file in the root of the project. If you open the file, you'll see three listed with each one on its own line in the file:

```txt
https://www.a11yproject.com/feed/feed.xml
https://webaim.org/blog/feed/
http://www.webaxe.org/feed/
```

If you want to remove a feed, just delete the line. If you want to add a feed, make sure it's on its own line. That's it! Happy reading. :)


Learn how to build your own RSS Reader App with Firebase Authentication and the RSS to JSON API.

How to Create Your Own Next.js RSS Reader App


Welcome to the fifth and final post in my new "Build a Blog Site with Next.js and Firebase" series! This series is pretty similar to a series I wrote in 2019: ["Build a React & Firebase Blog Site"](https://ashleemboyer.com/series/react-firebase-blog). Because it's been well over a year since I published that series, I decided to create a new series and use the Next.js React framework this time. It's a fun framework to use, and I know so many people that are curious about it. I hope you have enjoyed the series! As always, you can contact me through [Twitter](https://twitter.com/ashleemboyer) or [email](mailto:hello@ashleemboyer.com) if you run into any issues.

- _[Read Part 1 of the series](/blog/nextjs-firebase-blog-01)_
- _[Read Part 2 of the series](/blog/nextjs-firebase-blog-02)_
- _[Read Part 3 of the series](/blog/nextjs-firebase-blog-03)_
- _[Read Part 4 of the series](/blog/nextjs-firebase-blog-04)_

---

## Add a Page for Editing Posts

1. Add a new `updatePost` function to `lib/firebase.js`:

```js
/*
Updates the data for the given post in the database.
*/
export const updatePost = async (post) => {
  initFirebase();

  return firebase.database().ref(`/posts/${post.slug}`).set(post);
};
```

2. Add `edit.module.scss` to the `styles` directory:

```scss
.EditPage {
  form {
    h1 {
      margin-top: 0;
      margin-bottom: 24px;
    }

    input {
      margin-bottom: 16px;
    }

    textarea {
      height: 300px;
    }

    button {
      display: block;
      margin-right: 0;
      margin-left: auto;
      margin-top: 24px;
    }
  }
}
```

3. Add an `edit` directory to `pages`.
4. Add `[slug].js` to `pages/edit` directory:

```jsx
import { useState } from 'react';
import { useRouter } from 'next/router';
import { getPostBySlug, updatePost } from '@lib/firebase';
import { useAuth } from '@contexts/auth';
import { Layout } from '@components';
import styles from '@styles/edit.module.scss';

const EditPage = ({ post }) => {
  const router = useRouter();
  const [user, userLoading] = useAuth();
  const [values, setValues] = useState(post);
  const [isLoading, setIsLoading] = useState(false);

  if (userLoading) {
    return null;
  }

  if (!user && typeof window !== 'undefined') {
    router.push('/signin');
    return null;
  }

  const handleChange = (e) => {
    const id = e.target.id;
    const newValue = e.target.value;

    setValues({ ...values, [id]: newValue });
  };

  const handleSubmit = (e) => {
    e.preventDefault();

    let missingValues = [];
    Object.entries(values).forEach(([key, value]) => {
      if (!value) {
        missingValues.push(key);
      }
    });

    if (missingValues.length > 1) {
      alert(`You're missing these fields: ${missingValues.join(', ')}`);
      return;
    }

    setIsLoading(true);
    updatePost(values)
      .then(() => {
        setIsLoading(false);
        router.push(`/post/${post.slug}`);
      })
      .catch((err) => {
        alert(err);
        setIsLoading(false);
      });
  };

  return (
    <Layout>
      <div className={styles.EditPage}>
        <form onSubmit={handleSubmit}>
          <h1>Edit Post: {post.slug}</h1>
          <div>
            <label htmlFor="title">Title</label>
            <input
              id="title"
              type="text"
              value={values.title}
              onChange={handleChange}
            />
          </div>
          <div>
            <label htmlFor="coverImage">Cover Image URL</label>
            <input
              id="coverImage"
              type="text"
              value={values.coverImage}
              onChange={handleChange}
            />
          </div>
          <div>
            <label htmlFor="coverImageAlt">Cover Image Alt</label>
            <input
              id="coverImageAlt"
              type="text"
              value={values.coverImageAlt}
              onChange={handleChange}
            />
          </div>
          <div>
            <label htmlFor="content">Content</label>
            <textarea
              id="content"
              value={values.content}
              onChange={handleChange}
            />
          </div>
          <button type="submit" disabled={isLoading}>
            {isLoading ? 'Updating...' : 'Update'}
          </button>
        </form>
      </div>
    </Layout>
  );
};

export async function getServerSideProps(context) {
  const post = await getPostBySlug(context.query.slug);

  return {
    props: {
      post,
    },
  };
}

export default EditPage;
```

5. Go to `http://localhost:3000/edit/my-first-blog-post` in your browser. It should look a lot like the create page.
6. Change something about the post and click "Update".
7. You should be taken to the page for the post and should see your changes.
8. Commit and push your work to your repository:

```
git add .
git commit -m "Adding EditPage component"
git push
```

## Install FontAwesome

1. Install the `@fortawesome/fontawesome-svg-core`, `@fortawesome/free-solid-svg-icons`, and `@fortawesome/react-fontawesome` packages:

```bash
npm install @fortawesome/fontawesome-svg-core @fortawesome/free-solid-svg-icons @fortawesome/react-fontawesome
```

2. Load the icons in `pages/_app.js`:

```jsx
import { library } from '@fortawesome/fontawesome-svg-core';
import { fas } from '@fortawesome/free-solid-svg-icons';

library.add(fas);
```

3. Commit and push your work to your repository:

```
git add .
git commit -m "Installing FontAwesome"
git push
```

## Add an Icon component

We're going to make a wrapper component for the `FontAwesomeIcon` to make it easy to render an icon at different sizes and so we don't have to remember the import path for the `FontAwesomeIcon` component. The `classnames` package is great conditionally applying classes based on boolean props passed to a component. You can read more about the package [here](https://github.com/JedWatson/classnames#readme).

1. Install the `classnames` package:

```
npm install classnames
```

2. Add `Icon` directory to the `components` directory.
3. Add `Icon.module.scss` to the `components/Icon` directory:

```scss
$icon-small: 1rem;
$icon-medium: 1.5rem;
$icon-large: 2rem;

.Icon {
  width: $icon-medium;
  height: $icon-medium;
  font-size: $icon-medium;

  &--small {
    width: $icon-small;
    height: $icon-small;
    font-size: $icon-small;
  }

  &--large {
    width: $icon-large;
    height: $icon-large;
    font-size: $icon-large;
  }
}
```

4. Add `Icon.jsx` to the `components/Icon` directory:

```jsx
import classNames from 'classnames/bind';
import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
import styles from './Icon.module.scss';

const Icon = ({ name, small, large }) => {
  let cx = classNames.bind(styles);
  let className = cx('Icon', {
    'Icon--small': small,
    'Icon--large': large,
  });

  return <FontAwesomeIcon className={className} icon={name} />;
};

export default Icon;
```

5. Update `components/index.js` to export `Icon`:

```js
export { default as Icon } from './Icon/Icon';
```

6. Commit and push your work to your repository:

```
git add .
git commit -m "Adding Icon component"
git push
```

## Add a Link for EditPage

1. Import the new `Icon` component in `PostPage` (that's `pages/post/[slug.js]`):

```jsx
import { Icon, Layout } from '@components';
```

2. Also import `useAuth` in `PostPage`:

```jsx
import { useAuth } from '@contexts/auth';
```

3. Invoke `useAuth` after `useRouter` in `PostPage`:

```jsx
const [user] = useAuth();
```

4. Wrap the `<h1>` with the post's title in a `<div>` and also render an edit link in the `<div>` if there's an authenticated user:

```jsx
<div>
  <h1>{post.title}</h1>
  {user && (
    <a href={`/edit/${post.slug}`}>
      <Icon name="pencil-alt" />
    </a>
  )}
</div>
```

5. After the `<h1>` styles in `styles/post.module.scss`, add styles for the `<a>` element:

```scss
a {
  padding: 8px;
  color: black;
}
```

6. Go to `http://localhost:3000/post/my-first-blog-post` in your browser.
7. Click the new pencil icon.
8. You should be taken to the edit page for `my-first-blog-post`.
9. Commit and push your work to your repository:

```
git add .
git commit -m "Adding edit link"
git push
```

## Add a Delete Button

1. Add a new `deletePost` function in `lib/firebase.js`:

```js
/*
Deletes a post from the database.
*/
export const deletePost = async (slug) => {
  initFirebase();

  return firebase.database().ref(`/posts/${slug}`).set(null);
};
```

2. Import the `deletePost` function in `PostPage`:

```jsx
import { deletePost, getPostBySlug } from '@lib/firebase';
```

3. At the same level as the edit link we just added in the previous section, add a `<button>` and wrap both elements in a `div`:

```jsx
<span>
  <a href={`/edit/${post.slug}`}>
    <Icon name="pencil-alt" />
  </a>
  <button
    onClick={() => {
      const shouldDeletePost = confirm(
        'Are you sure you want to delete this post?',
      );
      if (shouldDeletePost) {
        deletePost(post.slug).then(() => {
          router.push('/');
        });
      }
    }}
  >
    <Icon name="trash-alt" />
  </button>
</span>
```

4. Replace the `a` styles you added to `styles/post.module.scss` with these:

```scss
& > div {
  display: flex;
  margin: 0;

  a {
    padding: 8px;
    color: black;
  }

  button {
    background: transparent;
    box-shadow: none;
    border: none;
    color: black;
  }
}
```

5. Create a new post for testing the delete functionality.
6. Go to the post's page and you should see a trashcan icon to the right of the pencil icon like this:

[![View of the trashcan and other icon.](https://firebasestorage.googleapis.com/v0/b/ashleemboyer-2018.appspot.com/o/images%2F2021%2F02%2Fnextjs-firebase-blog-05%2FCleanShot%202021-01-17%20at%2019.54.16.png?alt=media&token=5371736e-21fe-41b4-b3a0-ed9b5ad6cde0)](https://firebasestorage.googleapis.com/v0/b/ashleemboyer-2018.appspot.com/o/images%2F2021%2F02%2Fnextjs-firebase-blog-05%2FCleanShot%202021-01-17%20at%2019.54.16.png?alt=media&token=5371736e-21fe-41b4-b3a0-ed9b5ad6cde0)

7. Click the trashcan icon and you should see an alert that says "Are you sure you want to delete this post?"
8. Click OK and you should be taken back to the home page. That post will no longer be listed and it should also be gone from the database.
9. Commit and push your work to your repository:

```
git add .
git commit -m "Adding delete button"
git push
```

0. Celebrate!!! You did it!!! <span role="img" aria-label="party popper emoji">🎉</span>


Learn how to build a blog site with Next.js and Firebase.

Build a Blog Site with Next.js and Firebase

Build a Blog Site with Next.js and Firebase Part 5 - Editing & Deleting Posts


Welcome to the fourth post in my new "Build a Blog Site with Next.js and Firebase" series! This series is pretty similar to a series I wrote in 2019: ["Build a React & Firebase Blog Site"](/series/react-firebase-blog). Because it's been well over a year since I published that series, I decided to create a new series and use the Next.js React framework this time. It's a fun framework to use, and I know so many people that are curious about it. I hope you enjoy the series!

- _[Read Part 1 of the series](/blog/nextjs-firebase-blog-01)_
- _[Read Part 2 of the series](/blog/nextjs-firebase-blog-02)_
- _[Read Part 3 of the series](/blog/nextjs-firebase-blog-03)_
- _[Read Part 5 of the series](/blog/nextjs-firebase-blog-05)_

---

The importance of authentication in this app is making it so only _you_ can create, edit, and delete posts. It is _your_ blog after all. We'll use Firebase Authentication to manage a user account and we'll track the authentication state using React Context. Then we can hide certain parts of the app from people who aren't logged in.

## Set up Authentication in the Firebase Console

Firebase makes it easy for us to set up email/password authentication in our app. It's also easy to add a user for ourselves right from the console. Make sure you use a real email address and a secure password for your user. This is how you're protecting your blog! _There's a video after these steps that visually walks though how to do this._

1. Go to [the Firebase console](console.firebase.google.com) for your project.
2. Go to the "Authentication" page under "Build".
3. Click "Get Started".
4. You should be on the "Sign-in method" tab.
5. Click "Email/Password".
6. Enable the first toggle.
7. Click "Save".
8. Switch to the "Users" tab.
9. Click "Add user".
10. Enter a secure email and password.
11. Click "Add user".

<iframe title="Set up Email/Password Firebase Authentication" width="100%" height="350" src="https://www.youtube-nocookie.com/embed/WTnIU0ZtCoo" frameBorder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowFullScreen></iframe>

12. Go to your Realtime Database.
13. Click the "Rules" tab.
14. Update the rules to allow all reads but only authenticated writes:

```json
{
  "rules": {
    ".read": true,
    ".write": "auth != null"
  }
}
```

15. Click the "Publish" button.

## Manage Authentication State with React Context

1. Import `firebase/auth` into `lib/firebase.js` after the other Firebase imports:

```js
import 'firebase/auth';
```

2. Add an `onAuthStateChanged` function to `lib/firebase.js`:

```js
/*
Observes changes in authentication. Receives a callback function that is invoked
when auth state changes. See the Firebase Reference Docs for all of the details:
https://firebase.google.com/docs/reference/js/firebase.auth.Auth#onauthstatechanged
*/
export const onAuthStateChanged = async (callback) => {
  initFirebase();

  return firebase.auth().onAuthStateChanged((user) => callback(user));
};
```

3. Add a `contexts` directory at the root of the project.
4. Update `jsconfig.json` for the new `contexts` directory:

```json
{
  "compilerOptions": {
    "baseUrl": "./",
    "paths": {
      "@components": ["components"],
      "@contexts/*": ["contexts/*"],
      "@lib/*": ["lib/*"],
      "@styles/*": ["styles/*"]
    }
  }
}
```

5. Add an `auth.js` file to `contexts`:

```js
import { createContext, useState, useEffect, useContext } from 'react';
import { onAuthStateChanged } from '@lib/firebase';

const AuthContext = createContext({ user: null, userLoading: true });

export const AuthProvider = ({ children }) => {
  const [userLoading, setUserLoading] = useState(true);
  const [user, setUser] = useState();

  useEffect(() => {
    return onAuthStateChanged((res) => {
      setUser(res);
      setUserLoading(false);
    });
  }, []);

  return (
    <AuthContext.Provider value={[user, userLoading]}>
      {children}
    </AuthContext.Provider>
  );
};

export const useAuth = () => useContext(AuthContext);
```

6. Update `pages/_app.js` to use `AuthProvider`:

```js
import { AuthProvider } from '@contexts/auth';
import '@styles/global.scss';

const App = ({ Component, pageProps }) => (
  <AuthProvider>
    <Component {...pageProps} />
  </AuthProvider>
);

export default App;
```

7. Restart your development server if it's running.
8. Make sure your home page loads without error.
9. Commit and push your work to your repository:

```
git add .
git commit -m "Adding AuthContext"
git push
```

## Check for an Authenticated User in CreatePage

1. Import `useAuth` in `pages/create.js`:

```jsx
import { useAuth } from '@contexts/auth';
```

2. Invoke it in the component after the `isLoading` variable and log the results.

```jsx
const [user, userLoading] = useAuth();
console.log(user, userLoading);
```

3. Visit `http://localhost:3000/create` in your browser.
4. You should see three logs in the console:

```
undefined true
null true
null false
```

The first shows the initial values of `user` and `userLoading` when we invoke `useAuth`. The second shows those values after the `callback` we pass into `onAuthStateChanged` has been invoked and `setUser` has been called. The third shows after `setUserLoading` has been called in the same `callback`. This is why we call `setUser` before `setUserLoading`, so we can ensure that everything is truly loaded before changing that state.

4. Redirect to 404 if no user and return null if user is loading, before the `handleChange` and `handleSubmit` functions are defined. This placement prevents us from unecessarily defining those two functions if we're not going to use them.

```jsx
if (userLoading) {
  return null;
}

if (!user && typeof window !== 'undefined') {
  router.push('/404');
  return null;
}
```

5. Visit `http://localhost:3000/create` in your browser.
6. You should be redirected to the 404 page.
7. Commit and push your work to your repository:

```
git add .
git commit -m "Requiring Authentication in CreatePage"
git push
```

## Add a Page for Signing In

1. Add a new `signIn` function to `lib/firebase.js`:

```js
/*
Attempts to authenticate a user with a given email and password.
*/
export const signIn = async (email, password) => {
  initFirebase();

  return firebase.auth().signInWithEmailAndPassword(email, password);
};
```

2. Add `styles/signin.module.scss`:

```scss
.SignIn {
  max-width: 500px;
  margin: 32px auto;
  padding: 32px;
  background-color: white;
  border-radius: 4px;
  box-shadow: 0 2px 6px rgba(black, 0.3);

  form {
    h1 {
      margin: 0;
      margin-bottom: 24px;
      text-align: center;
    }

    input {
      margin-bottom: 16px;
    }

    button {
      min-width: 120px;
      display: block;
      margin-top: 32px;
      margin-right: auto;
      margin-left: auto;
    }
  }
}
```

3. Add `pages/signin.js`:

```jsx
import { useState } from 'react';
import { useRouter } from 'next/router';
import { signIn } from '@lib/firebase';
import { useAuth } from '@contexts/auth';
import styles from '@styles/signin.module.scss';

const SignInPage = () => {
  const router = useRouter();
  const [user, userLoading] = useAuth();
  const [values, setValues] = useState({ email: '', password: '' });

  if (userLoading) {
    return <h1>Loading...</h1>;
  }

  if (user && typeof window !== 'undefined') {
    router.push('/');
    return null;
  }

  const handleChange = (e) => {
    const id = e.target.id;
    const newValue = e.target.value;

    setValues({ ...values, [id]: newValue });
  };

  const handleSubmit = (e) => {
    e.preventDefault();

    let missingValues = [];
    Object.entries(values).forEach(([key, value]) => {
      if (!value) {
        missingValues.push(key);
      }
    });

    if (missingValues.length > 1) {
      alert(`You're missing these fields: ${missingValues.join(', ')}`);
      return;
    }

    signIn(values.email, values.password).catch((err) => {
      alert(err);
    });
  };

  return (
    <div className={styles.SignIn}>
      <form onSubmit={handleSubmit}>
        <h1>Please Sign In</h1>
        <label htmlFor="email">Email</label>
        <input
          id="email"
          type="email"
          value={values.email}
          onChange={handleChange}
        />
        <label htmlFor="password">Password</label>
        <input
          id="password"
          type="password"
          value={values.password}
          onChange={handleChange}
        />
        <button type="submit">Sign In</button>
      </form>
    </div>
  );
};

export default SignInPage;
```

4. Go to `http://localhost:3000/signin` in your browser.
5. Try logging in with the user credentials you created at the beginning of this post.
6. If successful, you should be sent to the home page.
7. Go to `http://localhost:3000/create` in your browser. You should not be redirected to the 404 page.
8. Commit and push your work to your repository:

```
git add .
git commit -m "Adding SignInPage"
git push
```

## Add a Sign Out Button to Layout

1. Add a new `signOut` function to `lib/firebase.js`:

```js
/*
Signs out the authenticated user.
*/
export const signOut = async () => {
  initFirebase();

  return firebase.auth().signOut();
};
```

2. Update the `Layout` component to check for a user and render a Sign Out button if there is one.

```jsx
import { signOut } from '@lib/firebase';
import { useAuth } from '@contexts/auth';
import styles from './Layout.module.scss';

const Layout = ({ children }) => {
  const [user] = useAuth();

  return (
    <div className={styles.Layout}>
      <nav>
        <span>
          <a href="/">My Next.js Blog</a>
        </span>
        {user && (
          <span>
            <button onClick={() => signOut()}>Sign Out</button>
          </span>
        )}
      </nav>
      <main>{children}</main>
    </div>
  );
};

export default Layout;
```

3. Update the `Layout` styles so the `<nav>` element uses Flexbox and the new button stands out from the blue bar.

```scss
.Layout {
  nav {
    display: flex;
    justify-content: space-between;
    align-items: center;
    ...

    span {
      ...

      button {
        color: #1a73e8;
        background-color: white;
      }
    }
  }

  ...
}
```

4. Go to `http://localhost:3000/` in your browser.
5. In the blue bar at the top, you should see a white button with blue text that reads "Sign Out" like this:

[![View of the Sign Out button.](https://firebasestorage.googleapis.com/v0/b/ashleemboyer-2018.appspot.com/o/images%2F2021%2F01%2Fnextjs-firebase-blog-04%2FCleanShot%202021-01-17%20at%2018.36.51.png?alt=media&token=9d34e42d-945c-4ad2-bc3a-9161cc34bc9b)](https://firebasestorage.googleapis.com/v0/b/ashleemboyer-2018.appspot.com/o/images%2F2021%2F01%2Fnextjs-firebase-blog-04%2FCleanShot%202021-01-17%20at%2018.36.51.png?alt=media&token=9d34e42d-945c-4ad2-bc3a-9161cc34bc9b)

6. Click the Sign Out button and check that you can no longer access the create page at `http://localhost:3000/create`.
7. Commit and push your work to your repository:

```
git add .
git commit -m "Adding Sign Out button to Layout"
git push
```

8. Celebrate!!! You did it!!! <span role="img" aria-label="party popper emoji">🎉</span>


Build a Blog Site with Next.js and Firebase Part 4 - Adding Authentication


Welcome to the third post in my new "Build a Blog Site with Next.js and Firebase" series! This series is pretty similar to a series I wrote in 2019: ["Build a React & Firebase Blog Site"](/series/react-firebase-blog). Because it's been well over a year since I published that series, I decided to create a new series and use the Next.js React framework this time. It's a fun framework to use, and I know so many people that are curious about it. I hope you enjoy the series!

- _[Read Part 1 of the series](/blog/nextjs-firebase-blog-01)_
- _[Read Part 2 of the series](/blog/nextjs-firebase-blog-02)_
- _[Read Part 4 of the series](/blog/nextjs-firebase-blog-04)_
- _[Read Part 5 of the series](/blog/nextjs-firebase-blog-05)_

---

## Create a Page Component for Each Post

In the site we've been building together, there currently isn't a way for people to read posts individually. We have the home page, which lists all blog posts, and we have a page for creating new posts. The good news is that we can handle rendering individual posts on their own pages pretty easily with [Next.js Dynamic Routes](https://nextjs.org/docs/routing/dynamic-routes). We just need to make sure we name the file correctly. Let's create a page component that just displays the `slug` from the URL as a test.

1. Add `post.module.scss` under the `styles` directory:

```scss
.PostPage {
  img {
    max-width: 100%;
    border-radius: 12px;
    border: 1px solid black;
  }

  h1 {
    margin-top: 20px;
    margin-bottom: 8px;
  }

  a {
    display: block;
    padding: 8px;
    color: black;
  }
}
```

2. Add a `post` directory to `pages`
3. Add `[slug].js` under the `post` directory:

```jsx
import { useRouter } from 'next/router';
import styles from '@styles/post.module.scss';

const PostPage = () => {
  const router = useRouter();
  const { slug } = router.query;

  return (
    <div className={styles.PostPage}>
      <h1>Hello, from post: {slug}!</h1>
    </div>
  );
};

export default PostPage;
```

4. Go to `https://localhost:3000/post/my-first-blog-post` in your browser
5. The page should look something like this:

[![White webpage with black text that reads "Hello, from post: my-first-blog-post!".](https://firebasestorage.googleapis.com/v0/b/ashleemboyer-2018.appspot.com/o/images%2F2021%2F01%2Fnextjs-firebase-blog-03%2FCleanShot%202021-01-17%20at%2013.46.33.png?alt=media&token=5fe24bde-e502-4fe8-af7c-8675261f2729)](https://firebasestorage.googleapis.com/v0/b/ashleemboyer-2018.appspot.com/o/images%2F2021%2F01%2Fnextjs-firebase-blog-03%2FCleanShot%202021-01-17%20at%2013.46.33.png?alt=media&token=5fe24bde-e502-4fe8-af7c-8675261f2729)

6. Commit and push your work to your repository:

```
git add .
git commit -m "Adding basic PostPage component"
git push
```

## Link to Each Post on the Home Page

Now that we have the pages for each post dynamically generating, we can link to them on the home page.

1. In `pages/index.js`, add this `<a>` element below the `<p>` where you set `dangerouslySetInnerHTML` with the post content:

```jsx
<a href={`/post/${post.slug}`}>Continue Reading</a>
```

2. In `styles/index.module.scss`, add `margin-bottom: 16px;` to the `p` element.
3. Below that style, add one for the `a` that sets the `color` to `#1a73e8`.
4. The home page should now look something like this:

[![Web page listing blog posts. Each has a black and white image of a random cat, a title in bold text, a date, excerpt, and blue link that reads "Continue Reading".](https://firebasestorage.googleapis.com/v0/b/ashleemboyer-2018.appspot.com/o/images%2F2021%2F01%2Fnextjs-firebase-blog-03%2FCleanShot%202021-01-17%20at%2014.01.54.png?alt=media&token=0acd5569-1da6-4e58-82da-48fb1f5ccb64)](https://firebasestorage.googleapis.com/v0/b/ashleemboyer-2018.appspot.com/o/images%2F2021%2F01%2Fnextjs-firebase-blog-03%2FCleanShot%202021-01-17%20at%2014.01.54.png?alt=media&token=0acd5569-1da6-4e58-82da-48fb1f5ccb64)

5. Commit and push your work to your repository:

```
git add .
git commit -m "Adding links to each post"
git push
```

## Load and Render Posts by Slug

Our `PostPage` component doesn't do much yet, so let's take care of that now. We'll need to add a function for getting a post's details from our Firebase Realtime Database and then update the `PostPage` component to render those details nicely.

1. Add a new `getPostBySlug` function to `lib/firebase.js` for getting the post from our Firebase Realtime Database:

```js
/*
Retrieves the data for a single post from a given slug.
*/
export const getPostBySlug = async (slug) => {
  initFirebase();

  return await firebase
    .database()
    .ref(`/posts/${slug}`)
    .once('value')
    .then((snapshot) => snapshot.val());
};
```

2. Import `getPostBySlug` at the top of `pages/post/[slug].js` (you can remove the `useRouter` import):

```jsx
import { getPostBySlug } from '@lib/firebase';
```

3. Right before `export default PostPage`, add `getServerSideProps` to `pages/post/[slug].js`.

```jsx
export async function getServerSideProps(context) {
  const post = await getPostBySlug(context.query.slug);

  return {
    props: {
      post,
    },
  };
}
```

4. Update the `PostPage` component to accept a `post` prop and render the post:

```jsx
const PostPage = ({ post }) => (
  <div className={styles.PostPage}>
    <img src={post.coverImage} alt={post.coverImageAlt} />
    <h1>{post.title}</h1>
    <span>Published {getFormattedDate(post.dateCreated)}</span>
    <p dangerouslySetInnerHTML={{ __html: post.content }}></p>
  </div>
);
```

5. `PostPage` uses the same `getFormattedDate` function as the home page, so let's add a `utils.js` file under the `lib` directory and export the function from there. You will have to restart you development server after this step if it's running.

```js
export const getFormattedDate = (milliseconds) => {
  const formatOptions = {
    weekday: 'long',
    month: 'long',
    day: 'numeric',
    year: 'numeric',
    timeZone: 'UTC',
  };
  const date = new Date(milliseconds);
  return date.toLocaleDateString(undefined, formatOptions);
};
```

6. Import `getFormattedDate` in both `pages/index.js` and `pages/post/[slug].js`:

```jsx
import { getFormattedDate } from '@lib/utils';
```

7. If you go to `http://localhost:3000/post/my-second-blog-post` in your browser, the page should look like this:

[![Webpage showing a black and white image of a random cat from PlaceKitten.com, the blog post title in bold font, the publish date, and the post content.](https://firebasestorage.googleapis.com/v0/b/ashleemboyer-2018.appspot.com/o/images%2F2021%2F01%2Fnextjs-firebase-blog-03%2FCleanShot%202021-01-17%20at%2014.27.44.png?alt=media&token=dfd51d27-3a21-4ae5-a50d-e0cf4b136682)](https://firebasestorage.googleapis.com/v0/b/ashleemboyer-2018.appspot.com/o/images%2F2021%2F01%2Fnextjs-firebase-blog-03%2FCleanShot%202021-01-17%20at%2014.27.44.png?alt=media&token=dfd51d27-3a21-4ae5-a50d-e0cf4b136682)

8. Commit and push your work to your repository:

```
git add .
git commit -m "Rendering posts in PostPage"
git push
```

## Add Site Navigation and Semantic HTML

### Add a Layout component

We've got our post pages, but now we need a way to navigate back to the home page! We also want the navigation to look the same on each page, so let's make a component for it that'll also help us consolidate some page styles.

1. Add a `components` directory at the root of your project.
2. Update `jsconfig.json` for the new `components` directory:

```json
{
  "compilerOptions": {
    "baseUrl": "./",
    "paths": {
      "@components": ["components"],
      "@lib/*": ["lib/*"],
      "@styles/*": ["styles/*"]
    }
  }
}
```

3. Add an `index.js` file for exporting all components from the directory.
4. Add a `Layout` directory under the `components` directory.
5. Add `Layout.jsx` to `components/Layout`:

```jsx
const Layout = ({ children }) => <div>{children}</div>;

export default Layout;
```

6. Update `components/index.js` to export Layout:

```jsx
export { default as Layout } from './Layout/Layout';
```

7. Import `Layout` into `pages/post/[slug].js`:

```jsx
import { Layout } from '@components';
```

8. Update `PostPage` so that the rendered contents are wrapped by the new `Layout` component:

```jsx
const PostPage = ({ post }) => (
  <Layout>
    <div className={styles.PostPage}>
      <img src={post.coverImage} alt={post.coverImageAlt} />
      <h1>{post.title}</h1>
      <span>Published {getFormattedDate(post.dateCreated)}</span>
      <p dangerouslySetInnerHTML={{ __html: post.content }}></p>
    </div>
  </Layout>
);
```

9. Restart your development server if it's running.
10. If you go to `http://localhost:3000/post/my-second-blog-post` in your browser, the page should still look like this:

[![Webpage showing a black and white image of a random cat from PlaceKitten.com, the blog post title in bold font, the publish date, and the post content.](https://firebasestorage.googleapis.com/v0/b/ashleemboyer-2018.appspot.com/o/images%2F2021%2F01%2Fnextjs-firebase-blog-03%2FCleanShot%202021-01-17%20at%2014.27.44.png?alt=media&token=dfd51d27-3a21-4ae5-a50d-e0cf4b136682)](https://firebasestorage.googleapis.com/v0/b/ashleemboyer-2018.appspot.com/o/images%2F2021%2F01%2Fnextjs-firebase-blog-03%2FCleanShot%202021-01-17%20at%2014.27.44.png?alt=media&token=dfd51d27-3a21-4ae5-a50d-e0cf4b136682)

11. Commit and push your work to your repository:

```
git add .
git commit -m "Adding new Layout component"
git push
```

### Add HTML landmarks to Layout

1. Add `Layout.module.scss` to `components/Layout`:

```SCSS
.Layout {
  nav {
    padding: 24px;
    background-color: #1a73e8;

    span {
      a {
        font-size: 1.6rem;
        font-weight: bold;
        color: white;
        text-decoration: none;

        &:hover {
          text-decoration: underline;
        }
      }
    }
  }

  main {
    padding: 24px;
  }
}
```

2. Import the styles in `components/Layout/Layout.jsx`:

```jsx
import styles from './Layout.module.scss';
```

3. Add a `className` to the `<div>` in `Layout` and add two elements: `<nav>` and `<main>`.

```jsx
const Layout = ({ children }) => (
  <div className={styles.Layout}>
    <nav>
      <span>
        <a href="/">My Next.js Blog</a>
      </span>
    </nav>
    <main>{children}</main>
  </div>
);
```

4. Go to `https://localhost:3000/post/my-second-blog-post` in your browser.
5. It should look something like this and you should be able to go to the home page with the new link at the top:

[![The same webpage as before but with a blue bar at the top and a white link to the home page that reads "My Next.js Blog".](https://firebasestorage.googleapis.com/v0/b/ashleemboyer-2018.appspot.com/o/images%2F2021%2F01%2Fnextjs-firebase-blog-03%2FCleanShot%202021-01-17%20at%2015.06.06.png?alt=media&token=dd59ce2b-4a3e-4ef0-a7c5-50b150548953)](https://firebasestorage.googleapis.com/v0/b/ashleemboyer-2018.appspot.com/o/images%2F2021%2F01%2Fnextjs-firebase-blog-03%2FCleanShot%202021-01-17%20at%2015.06.06.png?alt=media&token=dd59ce2b-4a3e-4ef0-a7c5-50b150548953)

6. Commit and push your work to your repository:

```
git add .
git commit -m "Adding nav and link to home page to Layout"
git push
```

## Consolidate Page Styles

Take a look styles in `index.module.scss`, `create.module.scss`, and `post.module.scss`. You should notice that all three of them have the same `max-width`, `margin`, and `padding` CSS properties set and the same values for each. This will be one benefit of having a `Layout` component: It helps you consolidate your styles and avoid repetition.

It also allows you to make styling changes accross all of your pages at once. For example, if you wanted to make the main content of your site narrower, you could update `max-width` in this one place to do so. Let's remove these three properties from `index.module.scss`, `create.module.scss`, and `post.module.scss` and use the new `Layout` component on these pages.

1. Import `Layout` in `pages/index.js` and `pages/create.js`:

```jsx
import { Layout } from '@components';
```

2. Wrap the rendered content in `pages/index.js` and `pages/create.js` with the opening and closing `Layout` tags.
3. Delete the `max-width`, `margin`, and `padding` from `index.module.scss`, `create.module.scss`, and `post.module.scss`.
4. Update the `main` styles in `components/Layout/Layout.module.scss` to handle `max-width`, `margin`, and `padding` for page content:

```scss
main {
  max-width: 700px;
  margin: 0 auto;
  padding: 24px;
}
```

5. All of your pages should have the same blue naviation bar at the top now.
6. Commit and push your work to your repository:

```
git add .
git commit -m "Using Layout in all pages and consolidating styles"
git push
```

## One last thing

What if someone tries to go to a post that doesn't exist? Let's try it. Go to `https://localhost:3000/post/abcdefg` in your browser. You should see a Server Error error that says `"Cannot read property 'coverImage' of null"`. This is because the `PostPage` component is expecting its `post` prop to be defined. Since the post isn't found in the database, our `getPostBySlug` is returning `null`. So, the `post` object passed to `PostPage` is null and doesn't have any attributes we can access off of it.

1. Import `useRouter` again in the `PostPage` component and check to see if `post` is defined. Redirect to `/404` if the post doesn't exist.

```jsx
const PostPage = ({ post }) => {
  const router = useRouter();

  if (!post) {
    router.push('/404');
    return;
  }

  return (
    <Layout>
      <div className={styles.PostPage}>
        <img src={post.coverImage} alt={post.coverImageAlt} />
        <h1>{post.title}</h1>
        <span>Published {getFormattedDate(post.dateCreated)}</span>
        <p dangerouslySetInnerHTML={{ __html: post.content }}></p>
      </div>
    </Layout>
  );
};
```

Uh oh! There's another Server Error: "No router instance found. you should only use "next/router" inside the client side of your app." This is happening because this code is running on the server side of our app and the `router.push` method is not supported there. You can read more about it at the link mentioned in the error.

2. To fix it, let's add an additional check to our `if` statement:

```jsx
if (!post && typeof window !== 'undefined') {
  router.push('/404');
  return;
}
```

If we run this, we still get a Server Error: "Cannot read property 'coverImage' of null". The `if` statement we just added is mainly for the client-side and doesn't tell the server-side what to do if the `post` object is undefined.

3. Add one more `if` statement below the first one that just returns `null` if `post` isn't defined.

```jsx
const PostPage = ({ post }) => {
  const router = useRouter();

  if (!post) {
    router.push('/404');
    return;
  }

  if (!post) {
    return null;
  }

  return (
    <Layout>
      <div className={styles.PostPage}>
        <img src={post.coverImage} alt={post.coverImageAlt} />
        <h1>{post.title}</h1>
        <span>Published {getFormattedDate(post.dateCreated)}</span>
        <p dangerouslySetInnerHTML={{ __html: post.content }}></p>
      </div>
    </Layout>
  );
};
```

4. Check that you're redirected to a 404 page.
5. Commit and push your work to your repository:

```
git add .
git commit -m "Redirecting to 404 if post doesn't exist"
git push
```

6. Celebrate!!! You did it!!! <span role="img" aria-label="party popper emoji">🎉</span>


Build a Blog Site with Next.js and Firebase Part 3 - Reading Each Post


Welcome to the second post in my new "Build a Blog Site with Next.js and Firebase" series! This series is pretty similar to a series I wrote in 2019: ["Build a React & Firebase Blog Site"](/series/react-firebase-blog). Because it's been well over a year since I published that series, I decided to create a new series and use the Next.js React framework this time. It's a fun framework to use, and I know so many people that are curious about it. I hope you enjoy the series!

- _[Read Part 1 of the series](/blog/nextjs-firebase-blog-01)_
- _[Read Part 3 of the series](/blog/nextjs-firebase-blog-03)_
- _[Read Part 4 of the series](/blog/nextjs-firebase-blog-04)_
- _[Read Part 5 of the series](/blog/nextjs-firebase-blog-05)_

---

## Add a Page for Creating Posts

First, let's add styles and a minimal component for our new `CreatePage` component.

1. Add `create.module.scss` in the `styles` directory:

```scss
.CreatePage {
  max-width: 700px;
  margin: 0 auto;
  padding: 24px;

  form {
    padding: 16px;

    h1 {
      margin-top: 0;
      margin-bottom: 24px;
    }

    input {
      margin-bottom: 16px;
    }

    textarea {
      height: 300px;
    }

    button {
      display: block;
      margin-right: 0;
      margin-left: auto;
      margin-top: 24px;
    }
  }
}
```

2. Add `create.js` in the `pages` directory:

```jsx
import styles from './create.module.scss';

const CreatePage = () => (
  <div styles={className.CreatePage}>
    <h1>Hello, from CreatePage!</h1>
  </div>
);

export default CreatePage;
```

3. Go to [http://localhost:3000/create](http://localhost:3000/create) in your browser. There's not much here because we first want to check that the files we've added work correctly before we add too much functionality. It should look like this:

[![A white webpage that reads "Hello from CreatePage!" in black text.](https://firebasestorage.googleapis.com/v0/b/ashleemboyer-2018.appspot.com/o/images%2F2021%2F01%2Fnextjs-firebase-blog-02%2FCleanShot%202021-01-10%20at%2014.13.47.png?alt=media&token=fb6d2174-34f6-4cc6-bf74-f23bbac592f9)](https://firebasestorage.googleapis.com/v0/b/ashleemboyer-2018.appspot.com/o/images%2F2021%2F01%2Fnextjs-firebase-blog-02%2FCleanShot%202021-01-10%20at%2014.13.47.png?alt=media&token=fb6d2174-34f6-4cc6-bf74-f23bbac592f9)

4. Commit and push your work to your repository:

```
git add .
git commit -m "Adding basic CreatePage component"
git push
```

## Make a Form for Describing Posts

Now that we've successfully added a page for creating posts, we can add a handful of inputs we'll use to describe posts. Let's review what attributes our posts have so we can decide what inputs we need. You can double-check the "shape" of posts by opening up your Firebase Realtime Database and expanding the objects in it. You should see these attributes (they're listed in alphabetical order in Firebase):

- `title`
- `slug`
- `dateCreated`
- `coverImage`
- `coverImageAlt`
- `content`

Of all of these attributes, there's one we can auto-generate when that "Create" button is clicked and don't need an input for: `dateCreated`. The rest need to be text `<input>`s and the `content` attribute will need a `<textarea>` so it's easy to write a lot of text. Let's add some styles for these new controls we're adding and then add them to the `CreatePage`.

1. Add styles for the new elements we're adding to the end of `styles/global.scss`:

```scss
label,
input,
textarea {
  display: block;
  width: 100%;
}

label {
  margin-bottom: 4px;
}

input,
textarea {
  padding: 4px;
  font-size: 1rem;
  font-family: Arial, Helvetica, sans-serif;
  border: 1px solid black;
  border-radius: 4px;
}

button {
  background-color: #1a73e8;
  border: 1px solid #1a73e8;
  border-radius: 4px;
  padding: 8px;
  color: white;
  font-size: 1rem;
  cursor: pointer;
}
```

2. Add some event handler functions and a `<form>` with the `<input>`, `<textarea>`, and `<button>` elements we need to `CreatePage`:

```jsx
import { useState } from 'react';
import styles from '@styles/create.module.scss';

const CreatePage = () => {
  const [formValues, setFormValues] = useState({
    title: '',
    slug: '',
    coverImage: '',
    coverImageAlt: '',
    content: '',
  });

  /*
  This is the function we're passing to each control so we can capture
  the value in it and store it in our `formValues` variable.
  */
  const handleChange = (e) => {
    const id = e.target.id;
    const newValue = e.target.value;

    setFormValues({ ...formValues, [id]: newValue });
  };

  /*
  This function is passed to the <form> and specifies what happens when
  the form is submitted. For now, we're going to log our `formValues`
  to verify that they are being managed correctly.
  
  Side note: we do not need to set an `onClick` for the <button> at the
  end of the form because it has type="submit". This allows us to click
  to submit the form or press the Enter key to submit it.
  */
  const handleSubmit = (e) => {
    // This prevents the default functionality of submitting a form
    e.preventDefault();

    console.log(formValues);
  };

  return (
    <div className={styles.CreatePage}>
      <form onSubmit={handleSubmit}>
        <h1>Create a new post</h1>
        <div>
          <label htmlFor="title">Title</label>
          <input
            id="title"
            type="text"
            value={formValues.title}
            onChange={handleChange}
          />
        </div>
        <div>
          <label htmlFor="slug">Slug</label>
          <input
            id="slug"
            type="text"
            value={formValues.slug}
            onChange={handleChange}
          />
        </div>
        <div>
          <label htmlFor="coverImage">Cover Image URL</label>
          <input
            id="coverImage"
            type="text"
            value={formValues.coverImage}
            onChange={handleChange}
          />
        </div>
        <div>
          <label htmlFor="coverImageAlt">Cover Image Alt</label>
          <input
            id="coverImageAlt"
            type="text"
            value={formValues.coverImageAlt}
            onChange={handleChange}
          />
        </div>
        <div>
          <label htmlFor="content">Content</label>
          <textarea
            id="content"
            value={formValues.content}
            onChange={handleChange}
          />
        </div>
        <button type="submit">Create</button>
      </form>
    </div>
  );
};

export default CreatePage;
```

3. Enter some data into each of the controls. Here's a list of what I'm entering as an example:

- `title`: My Third Blog Post
- `slug`: my-third-blog-post
- `coverImage`: https://placekitten.com/g/700/300
- `coverImageAlt`: A random kitten from PlaceKitten.com.
- `content`: Check me out! I'm writing my third blog post on a site I created. I'm so proud of myself!

4. Click the "Create" button.
5. Check the dev tools console.
6. Your page and console should look like this:

[![Window showing the create page and inputs on the left and the dev tools console on the right. The console shows an expanded JSON object with the form values correctly stored.](https://firebasestorage.googleapis.com/v0/b/ashleemboyer-2018.appspot.com/o/images%2F2021%2F01%2Fnextjs-firebase-blog-02%2FCleanShot%202021-01-10%20at%2014.52.21.png?alt=media&token=55cb793a-714e-4664-b67e-c2d8ddd3495a)](https://firebasestorage.googleapis.com/v0/b/ashleemboyer-2018.appspot.com/o/images%2F2021%2F01%2Fnextjs-firebase-blog-02%2FCleanShot%202021-01-10%20at%2014.52.21.png?alt=media&token=55cb793a-714e-4664-b67e-c2d8ddd3495a)

7. Commit and push your work to your repository:

```
git add .
git commit -m "Adding form and controls to CreatePage"
git push
```

## Write a Firebase Create Function

Our `CreatePage` component captures all the data we need to create a post. Now, we need to do something with that data.

1. Add a `createPost` function to `lib/firebase.js`:

```js
/*
Creates a new post under /posts in the Realtime Database. Automatically
generates the `dateCreated` property from the current UTC time in milliseconds.
*/
export const createPost = async (post) => {
  initFirebase();

  const dateCreated = new Date().getTime();
  post.dateCreated = dateCreated;

  return firebase.database().ref(`/posts/${post.slug}`).set(post);
};
```

2. Update the `CreatePage` component for fully creating posts. The code after this list of changes shows what your component should look like after making the updates.

- Import `useRouter` from `next/router` after the `useState` import.
- Import `createPost` from `@lib/firebase` after the `useRouter` import.
- Instantiate the `router` at the top of the `CreatePage` function.
- Add an `isLoading` state after the `formValues` instantiation.
- Update `handleSubmit` to check for missing values, set the `isLoading` state, and call `createPost`.
- Update the submit `<button>` to use `isLoading`.

```jsx
import { useState } from 'react';
import { useRouter } from 'next/router'; // this is new
import { createPost } from '@lib/firebase'; // this is new
import styles from '@styles/create.module.scss';

const CreatePage = () => {
  const router = useRouter(); // this is new
  const [formValues, setFormValues] = useState({
    title: '',
    slug: '',
    coverImage: '',
    coverImageAlt: '',
    content: '',
  });
  const [isLoading, setIsLoading] = useState(false); // this is new

  /*
  This is the function we're passing to each control so we can capture
  the value in it and store it in our `formValues` variable.
  */
  const handleChange = (e) => {
    const id = e.target.id;
    const newValue = e.target.value;

    setFormValues({ ...formValues, [id]: newValue });
  };

  /*
  This function is passed to the <form> and specifies what happens when
  the form is submitted. For now, we're going to log our `formValues`
  to verify that they are being managed correctly.
  
  Side note: we do not need to set an `onClick` for the <button> at the
  end of the form because it has type="submit". This allows us to click
  to submit the form or press the Enter key to submit it.
  */
  const handleSubmit = (e) => {
    // This prevents the default functionality of submitting a form
    e.preventDefault();

    // Check if there are any missing values.
    let missingValues = [];
    Object.entries(formValues).forEach(([key, value]) => {
      if (!value) {
        missingValues.push(key);
      }
    });

    // Alert and prevent the post from being created if there are missing values.
    if (missingValues.length > 1) {
      alert(`You're missing these fields: ${missingValues.join(', ')}`);
      return;
    }

    // Update the isLoading state.
    setIsLoading(true);

    // Start the attempt to create a new post.
    createPost(formValues)
      .then(() => {
        // Update the isLoading state and navigate to the home page.
        setIsLoading(false);
        router.push('/');
      })
      .catch((err) => {
        // Alert the error and update the isLoading state.
        alert(err);
        setIsLoading(false);
      });
  };

  return (
    <div className={styles.CreatePage}>
      <form onSubmit={handleSubmit}>
        <h1>Create a new post</h1>
        <div>
          <label htmlFor="title">Title</label>
          <input
            id="title"
            type="text"
            value={formValues.title}
            onChange={handleChange}
          />
        </div>
        <div>
          <label htmlFor="slug">Slug</label>
          <input
            id="slug"
            type="text"
            value={formValues.slug}
            onChange={handleChange}
          />
        </div>
        <div>
          <label htmlFor="coverImage">Cover Image URL</label>
          <input
            id="coverImage"
            type="text"
            value={formValues.coverImage}
            onChange={handleChange}
          />
        </div>
        <div>
          <label htmlFor="coverImageAlt">Cover Image Alt</label>
          <input
            id="coverImageAlt"
            type="text"
            value={formValues.coverImageAlt}
            onChange={handleChange}
          />
        </div>
        <div>
          <label htmlFor="content">Content</label>
          <textarea
            id="content"
            value={formValues.content}
            onChange={handleChange}
          />
        </div>
        <button type="submit" disabled={isLoading}>
          {isLoading ? 'Creating...' : 'Create'}
        </button>
      </form>
    </div>
  );
};

export default CreatePage;
```

3. Fill out the form with data such as this:

- `title`: My Third Blog Post
- `slug`: my-third-blog-post
- `coverImage`: https://placekitten.com/g/700/300
- `coverImageAlt`: A random kitten from PlaceKitten.com.
- `content`: Check me out! I'm writing my third blog post on a site I created. I'm so proud of myself!

4. Click the "Create" button.
5. When it's finished loading, you should see the home page and your new post at the top of the list.

[![Window showing the home page and list of blog posts.](https://firebasestorage.googleapis.com/v0/b/ashleemboyer-2018.appspot.com/o/images%2F2021%2F01%2Fnextjs-firebase-blog-02%2FCleanShot%202021-01-10%20at%2015.22.04.png?alt=media&token=b2c47ab7-43e9-42bd-9454-ed33f8a8d4e2)](https://firebasestorage.googleapis.com/v0/b/ashleemboyer-2018.appspot.com/o/images%2F2021%2F01%2Fnextjs-firebase-blog-02%2FCleanShot%202021-01-10%20at%2015.22.04.png?alt=media&token=b2c47ab7-43e9-42bd-9454-ed33f8a8d4e2)

6. Commit and push your work to your repository:

```
git add .
git commit -m "Adding createPost function and using it in CreatePage"
git push
```

7. Celebrate!!! You did it!!! <span role="img" aria-label="party popper emoji">🎉</span>

Don't forget that [last time](/nextjs-firebase-blog-01), we [deployed our site to Vercel](/nextjs-firebase-blog-01#deploy-to-vercel). With every `git push` we've done, Vercel has re-built your site for you! It's already updated and you can share your progress with everyone you know. :)


Build a Blog Site with Next.js and Firebase Part 2 - Creating New Posts


Welcome to the first post in my new "Build a Blog Site with Next.js and Firebase" series! This series is pretty similar to a series I wrote in 2019: ["Build a React & Firebase Blog Site"](https://ashleemboyer.com/series/react-firebase-blog). Because it's been well over a year since I published that series, I decided to create a new series and use the Next.js React framework this time. It's a fun framework to use, and I know so many people that are curious about it. I hope you enjoy the series!

- _[Read Part 2 of the series](/blog/nextjs-firebase-blog-02)_
- _[Read Part 3 of the series](/blog/nextjs-firebase-blog-03)_
- _[Read Part 4 of the series](/blog/nextjs-firebase-blog-04)_
- _[Read Part 5 of the series](/blog/nextjs-firebase-blog-05)_

---

## Firebase Setup

First, let's create a new project in Firebase. _There's a video after these steps that visually walks though how to do this._

1. Go to [console.firebase.google.com](https://console.firebase.google.com) and make sure you're logged in with the Google account you want to use.
2. Click the card that says "Add project". It should be the first one listed.
3. Enter a project name. I'm going to use `nextjs-firebase-blog` for the entire series.
4. Toggle "Enable Google Analytics for this project" to off.
5. Click "Create project".
6. Click "Continue" when your new project is ready.

<iframe title="Create a New Firebase Project" width="100%" height="350" src="https://www.youtube-nocookie.com/embed/2w5BV9ft82g" frameBorder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowFullScreen></iframe>

Now that we have a project, we can set up the database and add some test data to it. _There's a video after these steps that visually walks though how to do this._

1. Click "Realtime Database" in the left-hand sidebar.
2. Click the "Create Database" button.
3. Keep the given location setting and click the "Next" button.
4. Select the "Start in test mode" option.
5. Click the "Enable" button.

<iframe title="Enable Firebase Realtime Database" width="100%" height="350" src="https://www.youtube-nocookie.com/embed/DQU0rcHce1c" frameBorder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowFullScreen></iframe>

Since we won't have an interface for creating new posts until after Part 2 of this series, we need to add some test data to our database. Firebase makes it easy to import data from a JSON file. That's how we're going to add our test data. _There's a video after these steps that visually walks though how to do this._

1. Wherever you store code on your machine, create a new folder for this project. I'm calling mine `nextjs-firebase-blog`.
2. Add a file to it called `data.json`.
3. Paste this block of code in the JSON file:

```json
{
  "posts": {
    "my-first-blog-post": {
      "content": "Cupcake ipsum dolor sit amet carrot cake. Sweet tootsie roll marzipan jelly-o cake cotton candy pie. Jelly-o powder tootsie roll. Toffee gummi bears muffin powder caramels dragée soufflé. Halvah gummies gingerbread jelly jujubes. Sweet toffee lollipop chocolate cake.",
      "coverImage": "http://placekitten.com/g/700/400",
      "coverImageAlt": "A random kitten from PlaceKitten.com",
      "dateCreated": 1609718400000,
      "slug": "my-first-blog-post",
      "title": "My First Blog Post"
    },
    "my-second-blog-post": {
      "content": "Cupcake ipsum dolor sit amet carrot cake. Sweet tootsie roll marzipan jelly-o cake cotton candy pie. Jelly-o powder tootsie roll. Toffee gummi bears muffin powder caramels dragée soufflé. Halvah gummies gingerbread jelly jujubes. Sweet toffee lollipop chocolate cake.",
      "coverImage": "http://placekitten.com/g/700/500",
      "coverImageAlt": "A random kitten from PlaceKitten.com",
      "dateCreated": 1609459200000,
      "slug": "my-second-blog-post",
      "title": "My Second Blog Post"
    }
  }
}
```

4. Go to your Realtime Database in Firebase.
5. Click the vertical ellipsis menu icon. It's to the right of a circle minus sign icon.
6. Select the "Import JSON" menu option.
7. Browse for the `data.json` file you just created.
8. Click the "Import" button.

<iframe title="Add Test Data to Firebasebase Realtime Database" width="100%" height="350" src="https://www.youtube-nocookie.com/embed/gWp1Jn9ed5E" frameBorder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowFullScreen></iframe>

## Next.js Setup

Let's spend some time in our terminal and code editor now. We need to add some inital packages and files to the same place that we created our `data.json` file in the previous section. The next few steps are commands that need to be run in a terminal, so go ahead and fire it up if you haven't already.

_Make sure you run the commands in steps 1 and 2 in your `nextjs-firebase-blog` directory._

1. `npm init -y` to set up your `package.json` file.
2. `npm install next react react-dom sass firebase` to install all the necessary packages.
3. Open `package.json` in your code editor.
4. Update the `"scripts"` property to have `dev`, `build`, and `start` properties like this:

```json
{
  "scripts": {
    "dev": "next dev",
    "build": "next build",
    "start": "next start"
  }
}
```

5. Add a `pages` directory.
6. Add `_app.js` to the `pages` directory and write this code in it:

```jsx
// This is called a "Custom `App` in Next.js.
// We use it for global styles and will later use it for loading an
// icon library. You can read more about this in the Next.js docs at:
// https://nextjs.org/docs/advanced-features/custom-app

import '@styles/global.scss';

const App = ({ Component, pageProps }) => <Component {...pageProps} />;

export default App;
```

7. Add a `jsconfig.json` file in the root of the project:

```json
// This file is for absolute imports and module path aliases.
// It'll help us keep our import statements nice and clean!
// You can read more about this in the Next.js docs at:
// https://nextjs.org/docs/advanced-features/module-path-aliases

{
  "compilerOptions": {
    "baseUrl": "./",
    "paths": {
      "@styles/*": ["styles/*"]
    }
  }
}
```

8. Add a `styles` directory in the root of the project.
9. Add `global.scss` to the `styles` directory:

```scss
// This is where global site styles go.

* {
  box-sizing: border-box;
}

body {
  margin: 0;
  font-family: Arial, Helvetica, sans-serif;
}
```

10. Add `index.module.scss` to the `styles` directory:

```scss
// These styles go with the index page.

.HomePage {
  max-width: 700px;
  margin: 0 auto;
  padding: 24px;

  h1 {
    margin-bottom: 32px;
  }

  article {
    border: 1px solid black;
    border-radius: 12px;
    overflow: hidden;

    &:not(:last-child) {
      margin-bottom: 32px;
    }

    div {
      padding: 16px;

      h2 {
        margin-top: 0;
        margin-bottom: 4px;
      }

      span {
        display: block;
        margin-bottom: 12px;
      }

      p {
        margin: 0;
      }
    }
  }
}
```

11. Add `index.js` to the `pages` directory:

```jsx
// This component represents the index page for the site. You
// can read more about Pages in the Next.js docs at:
// https://nextjs.org/docs/basic-features/pages

import styles from '@styles/index.module.scss';

const HomePage = () => (
  <div className={styles.HomePage}>
    <h1>Hello from HomePage!</h1>
  </div>
);

export default HomePage;
```

12. In your terminal, start the application in development mode with `npm run dev`.
13. Go to [http://localhost:3000](http://localhost:3000) in your browser. It should look like this (mine is zoomed in for visibility):

[![A white webpage that reads "Hello from HomePage!" in black text.](https://firebasestorage.googleapis.com/v0/b/ashleemboyer-2018.appspot.com/o/images%2F2021%2F01%2Fnextjs-firebase-blog-01%2FCleanShot%202021-01-03%20at%2023.20.21.png?alt=media&token=a9c0cbb2-703d-48c5-8f31-5128830f06b1)](https://firebasestorage.googleapis.com/v0/b/ashleemboyer-2018.appspot.com/o/images%2F2021%2F01%2Fnextjs-firebase-blog-01%2FCleanShot%202021-01-03%20at%2023.20.21.png?alt=media&token=a9c0cbb2-703d-48c5-8f31-5128830f06b1)

## Create a Repository and Commit Progress

This is a great place to stop and commit because you have a working version of your app. You want this code in a repository for a quite a few reasons:

- A clear commit history is an efficient way to remind yourself what you did.
- You can access the code from multiple machines.
- Other people will be able to see what you've created. ([Learning out loud](https://ashleemboyer.com/what-it-means-to-learn-out-loud) is definitely a good thing!)
- Vercel makes it easy to deploy from GitHub repositories.

1. Go to [https://github.com/new](https://github.com/new)
2. Name your repository `nextjs-firebase-blog`.
3. Add a description like "My awesome blog built with Next.js and Firebase!"
4. Click the "Create repository" button.

_The next few steps will be run in your terminal._

5. `git init` to initialize a Git repository in your project directory.
6. Add a `.gitignore` file so we can avoid adding unnecessary files to the repository:

```gitignore
.next
node_modules
```

7. `git add .` to stage all of your files for a commit.
8. `git commit -m "First commit"` to create the commit and add a message to it.
9. `git branch -M main` to rename the `master` branch to `main`
10. `git remote add origin <shortname>` where `<shortname>` is the one associated with your repository.
11. `git push -u origin main` to push your commits to the repository.
12. Refresh GitHub in your browser and your repository should have all of your code.

[![View of the code repository at GitHub.com.](https://firebasestorage.googleapis.com/v0/b/ashleemboyer-2018.appspot.com/o/images%2F2021%2F01%2Fnextjs-firebase-blog-01%2FCleanShot%202021-01-04%20at%2000.14.23.png?alt=media&token=ec15ed14-f50d-472a-9b76-066f6a794be1)](https://firebasestorage.googleapis.com/v0/b/ashleemboyer-2018.appspot.com/o/images%2F2021%2F01%2Fnextjs-firebase-blog-01%2FCleanShot%202021-01-04%20at%2000.14.23.png?alt=media&token=ec15ed14-f50d-472a-9b76-066f6a794be1)

## Display the Test Data

In order to read data from our Firebase Realtime Database, we need to initialize a Firebase app within our site. This will require three config variables that Firebase provides: `apiKey`, `databaseURL`, and `projectId`. We'll store these variables in an environment file and git ignore it so we don't accidentally share secret information with the public.

1. Update your `.gitignore` to include `.env`:

```gitignore
.next
node_modules
.env
```

2. Go to your project settings in the Firebase console.
3. Scroll to the bottom of the page where it says "Your apps."
4. Click the `</>` button to register your app for web.
5. For "App nickname", enter `nextjs-firebase-blog`.
6. Click the "Register app" button and keep this page open.
7. Add a `.env` file in the root of the project and paste your `apiKey`, `databaseURL`, and `projectId` in the correct places:

```env
NEXT_PUBLIC_FIREBASE_API_KEY=<your api key>
NEXT_PUBLIC_FIREBASE_DATABASE_URL=<your database url>
NEXT_PUBLIC_FIREBASE_PROJECT_ID=<your project id>
```

8. You can leave this page by clicking the "Continue to console" button.
9. Add a `lib` directory in the root of the project.
10. Add a `firebase.js` file:

```js
// This is where we'll add all of the functions for interacting with
// Firebase services in our app.

import firebase from 'firebase/app';
import 'firebase/database';

const initFirebase = async () => {
  // This check prevents us from initializing more than one app.
  if (!firebase.apps.length) {
    firebase.initializeApp({
      apiKey: process.env.NEXT_PUBLIC_FIREBASE_API_KEY,
      databaseURL: process.env.NEXT_PUBLIC_FIREBASE_DATABASE_URL,
      projectId: process.env.NEXT_PUBLIC_FIREBASE_PROJECT_ID,
    });
  }
};

// Gets all posts from the database in reverse chronological order.
export const getPosts = async () => {
  // Because our exported functions can be called at any time from
  // any place in our app, we need to make sure we've initialized
  // a Firebase app every time these functions are invoked.
  initFirebase();

  const posts = await firebase
    .database()
    .ref('/posts')
    .orderByChild('dateCreated')
    .once('value')
    .then((snapshot) => {
      const snapshotVal = snapshot.val();

      const result = [];
      for (var slug in snapshotVal) {
        const post = snapshotVal[slug];
        result.push(post);
      }

      return result.reverse();
    });

  return posts;
};
```

11. Update `jsconfig.json` for the new `lib` directory:

```json
{
  "compilerOptions": {
    "baseUrl": "./",
    "paths": {
      "@lib/*": ["lib/*"],
      "@styles/*": ["styles/*"]
    }
  }
}
```

12. Import the `getPosts` in `pages/index.js` as the first import:

```jsx
import { getPosts } from '@lib/firebase';
```

13. Below the imports, add a helper function for formatting the date of a post:

```js
const getFormattedDate = (milliseconds) => {
  const formatOptions = {
    weekday: 'long',
    month: 'long',
    day: 'numeric',
    year: 'numeric',
    timeZone: 'UTC',
  };
  const date = new Date(milliseconds);
  return date.toLocaleDateString(undefined, formatOptions);
};
```

14. After the `HomePage` component initialization and before `export default HomePage`, add `getServerSideProps` for fetching posts from the database:

```js
// This is for fetching data every time the page is visited. We do this
// so that we don't have to redploy the site every time we add a blog post.
// You can read more about this in the Next.js docs at:
// https://nextjs.org/docs/basic-features/data-fetching#getserversideprops-server-side-rendering

export async function getServerSideProps() {
  const posts = await getPosts();

  return {
    props: {
      posts,
    },
  };
}
```

15. Update the `HomePage` component to accept a `posts` prop and to render the given `posts`:

```jsx
const HomePage = ({ posts }) => (
  <div className={styles.HomePage}>
    <h1>Blog Posts</h1>
    {posts.map((post) => (
      <article key={post.slug}>
        <img src={post.coverImage} alt={post.coverImageAlt} />
        <div>
          <h2>{post.title}</h2>
          <span>{getFormattedDate(post.dateCreated)}</span>
          <p
            dangerouslySetInnerHTML={{
              __html: `${post.content.substring(0, 200)}...`,
            }}
          ></p>
        </div>
      </article>
    ))}
  </div>
);
```

16. Stop the development server if it's running.
17. `npm run dev` to start the development server.
18. Go to [http://localhost:3000/](http://localhost:3000/) in your browser and it should look something like this:

[![The blog site showing a "Blog Posts" heading and a list of two posts showing the test data.](https://firebasestorage.googleapis.com/v0/b/ashleemboyer-2018.appspot.com/o/images%2F2021%2F01%2Fnextjs-firebase-blog-01%2FCleanShot%202021-01-04%20at%2000.43.45.png?alt=media&token=5574ca53-9e33-49e2-aab0-9b8a8b23f150)](https://firebasestorage.googleapis.com/v0/b/ashleemboyer-2018.appspot.com/o/images%2F2021%2F01%2Fnextjs-firebase-blog-01%2FCleanShot%202021-01-04%20at%2000.43.45.png?alt=media&token=5574ca53-9e33-49e2-aab0-9b8a8b23f150)

19. You've done quite a bit of work now, so make sure you commit and push it in your terminal:

```bash
git add .
git commit -m "Showing test data on HomePage"
git push
```

## Deploy to Vercel

Woot! We're at the last step! We've got a basic little blog site that lists posts from a Firebase Realtime Database. You should be so proud of yourself. Let's get this deployed to Vercel so you can show it off! _There's a video after these steps that visually walks though how to do this._

1. Go to [vercel.com/new](https://vercel.com/new). You may have to create an account.
2. Find your `nextjs-firebase-blog` repository and click the "Import" button next to it.
3. Select your personal account for the Vercel Scope.
4. Click the "Deploy" button.
5. Wait for the deploy to finish, but don't visit the site just yet.

<iframe title="Deploy Project to Vercel" width="100%" height="350" src="https://www.youtube-nocookie.com/embed/JyoalVxk0ew" frameBorder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowFullScreen></iframe>

6. Go the Project Settings in Vercel.
7. Click Environment Variables from the left-hand sidebar.
8. Scroll down to the "Add New" section.
9. Choose "Plaintext".
10. For the `name`, put `NEXT_PUBLIC_FIREBASE_API_KEY`.
11. For the `value`, enter the value you have for the variable from your `.env` file.
12. Click the "Save" button.
13. Repeat steps 9-12 for the other two variables in your `.env` file: `NEXT_PUBLIC_FIREBASE_DATABASE_URL` and `NEXT_PUBLIC_FIREBASE_PROJECT_ID`.

You should now have 3 environment variables that match the ones in your `.env` file. A deployment is required for these changes to take effect, so let's finish up with that last task. _There's a video after these steps that visually walks though how to do this._

1. Go to your project overview.
2. Scroll to the Production Deployment section.
3. Under "DEPLOYMENT" in that section, click the link. It's the first one listed. You'll be taken to the Overview page for this specific deploy.
4. Click the vertical ellipsis menu directly to the left of the "Visit" button.
5. Choose the "Redploy" menu option.
6. Click the "Redeploy" button in the modal that pops up.
7. Wait for the deploy to finish.
8. Click the "Visit" button when it appears.
9. Celebrate!!! You did it!!! <span role="img" aria-label="party popper emoji">🎉</span>

<iframe title="Add Environment Variables in Vercel and Redeploy to Effect Changes" width="100%" height="350" src="https://www.youtube-nocookie.com/embed/Tgo8NPEGxis" frameBorder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowFullScreen></iframe>


Posts Related to the "nextjs" Tag