How I built a Markdown Rendered Blog using Supabase and Chakra UI
Tags: react, javascript, webdev, beginners
Published: 2024-04-23 11:30:05

# Introduction

I was building a project for myself where I needed to build a blog. As a technical writer, I have always written markdown articles once I understand them. Rather than using a text formatter, I wanted to build a blog that renders the Markdown. In this article, I'll walk you through the process of building a Markdown-rendered blog using Supabase and Chakra UI. 

[**Supabase**](https://supabase.com/) will be used for storing article data in the database and the cover image of the article in storage. [**Chakra UI**](https://v2.chakra-ui.com/) will be used to provide style to the elements. By using both, we can build the blog with ease.

In the project, we are going to create 3 routes:

- **/(root):** It will display all the articles in the grid format.
- **/create:** It will be used to create an article by providing a name, description, and markdown version of the article.
- **/[slug]:** It will render the markdown article.

Now, let’s get started building the project.

# Setting up the Environment

Let’s set the environment for building the project. As for the frontend framework, we are going to use NextJS with the app directory. It will be helpful in routing and navigation. Install the NextJS project with the below command:

```bat
    npx create-next-app@latest supabase-blog
```

Use the below setting for the NextJS:

![NextJS setting](https://paper-attachments.dropboxusercontent.com/s_A1F14CB9F9D9154D0EBE8EC24C80324C8F0438DE22B4D8CBB6325295C0479B1E_1713421325586_image.png)

> Note: To run the above command, You need to have NodeJS and NPM pre-installed on your system.

Once the NextJS project is installed, we can now install the dependencies.

## ChakraUI

In the root directory of the project run the below command to install the Chakra UI.

```bat
    npm i @chakra-ui/react @emotion/react @emotion/styled framer-motion chakra-react-select react-toastify
```

I have additionally added `chakra-react-select` and `react-toastify` for improving the dropdown select and notifying the user about the response respectively. After installation, we need to update the `layout.js` from the app directory. Here is the code:

```jsx
    "use client";
    import { Inter } from "next/font/google";
    import "./globals.css";
    import { ChakraProvider } from "@chakra-ui/react";
    import { ToastContainer } from "react-toastify";
    import "react-toastify/dist/ReactToastify.css";
    import theme from "../theme/theme";
    
    const inter = Inter({ subsets: ["latin"] });
    export default function RootLayout({ children }) {
      return (
        <html lang="en">
          <body className={inter.className}>
            <ChakraProvider theme={theme}>
              <ToastContainer />
              {children}
            </ChakraProvider>
          </body>
        </html>
      );
    }
```

We have used the “use client” at the top of the file to do Client Side Rendering for Chakra UI. Other than is self-explanatory. The `theme` which is imported is the Customized theme of the Charka UI component. You can look [here](https://github.com/surajondev/supabase-blog/tree/master/theme) for all the customized components.


## Supabase

Let’s set up the Supabse in our project. Install the Supabase client for JavaScript with the following command:

```bat
    npm i npm install @supabase/supabase-js
```

Now, we need to create a project in the Supabase dashboard for accessing the API key. Visit Supabse and create an account. Additionally, you can refer to the Supabase section of [**this**](https://dev.to/surajondev/using-chatgpt-with-your-own-data-using-langchain-and-supabase-4k6c#supabase) article for creating a project. 

Now, create a `lib` directory in the root for putting the supabase client here. 

```js
    import { createClient } from "@supabase/supabase-js";
    
    const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL;
    const anonKey = process.env.NEXT_PUBLIC_SUPABASE_ANON;
    
    export const supabase = createClient(supabaseUrl, anonKey);
```

`SUPABASE_URL` and `SUPABASE_ANON` are secrets that can be found in the Supabase App dashboard. Go to Project Setting → API, you will find it there. You also need to create the `.env` file in the root for storing the env.

```env
    NEXT_PUBLIC_SUPABASE_URL=<SUPABASE_URL>
    NEXT_PUBLIC_SUPABASE_ANON=<SUPABASE_ANON>
```

We need to create a database table and storage in Supabse for storing article data and cover images respectively. Create a table from `Table Editor` with the following table columns.

![Table data](https://paper-attachments.dropboxusercontent.com/s_A1F14CB9F9D9154D0EBE8EC24C80324C8F0438DE22B4D8CBB6325295C0479B1E_1713423564006_image.png)


Make sure tags are taken as an array. You can do that by clicking the setting in front of tags and selecting Define as Array. Also, deselect the Row Level Security.

![Row Level Security](https://paper-attachments.dropboxusercontent.com/s_A1F14CB9F9D9154D0EBE8EC24C80324C8F0438DE22B4D8CBB6325295C0479B1E_1713423699729_image.png)

Row-level security is useful in making database requests directly from the client. If enabled only specified users are allowed to access the data as per policy. It can help build a serverless SaaS. 

From storage create a bucket with the `thumbnail` name and make sure the Public bucket is enabled.

![Bucket](https://paper-attachments.dropboxusercontent.com/s_A1F14CB9F9D9154D0EBE8EC24C80324C8F0438DE22B4D8CBB6325295C0479B1E_1713424177835_image.png)


One more thing, select  Policies from Configuration in Storage. From here Click `New Policy` in front t of the thumbnail and then select `For Full customization`.  Enable `SELECT` and `INSERT`  operations and give a name as shown below. Now, click on Review and then Save Policy.

![Row level Security - Supabase](https://paper-attachments.dropboxusercontent.com/s_A1F14CB9F9D9154D0EBE8EC24C80324C8F0438DE22B4D8CBB6325295C0479B1E_1713424446738_image.png)

Now, the Supabase setup is completed. 

## Additional dependencies

We need two more dependencies to complete the setup. You can install it with the below command:

```bat
    npm i chakra-ui-markdown-renderer formik
```

The first one will be used to convert the markdown syntax into an HTML component with the desired Chakra UI theme. Formik for handling the form input for article data.

## Project Structure

As discussed above we are going to have 3 routes. Here is the structure in the app directory.

```
    --app
        --page.js
        --create
                --page.js
        --[slug]
                --page.js
```

Let’s first start with the root directory.

# /(root)

In the root, we are going to display the article. Here is the code for the file.

```jsx
    // Import is not added for all the code files. You can get the whole code from the GitHub repo mentioned below.
    
    const BlogTags = (props) => {
      const { marginTop = 0, tags } = props;
      return (
        <HStack spacing={2} marginTop={marginTop}>
          {tags.map((tag) => {
            return (
              <Tag size={"md"} variant="solid" colorScheme="orange" key={tag}>
                {tag}
              </Tag>
            );
          })}
        </HStack>
      );
    };
    
    const ArticleList = () => {
      const [articleData, setArticleData] = useState();
      const getArticleData = async () => {
        const { data: articleData, error: artilceError } = await supabase
          .from("article")
          .select();
        if (artilceError) {
          console.log(artilceError);
        } else {
          setArticleData(articleData);
          console.log(articleData);
        }
      };
      useEffect(() => {
        getArticleData();
      }, []);
      return (
        <Box marginTop="20" className="mainContainer">
          <Heading variant="primary-heading" mt={20}>
            Stories by Suraj Vishwakarma
          </Heading>
          <Flex justifyContent="space-between">
            <Heading variant="secondary-heading" marginTop="10" marginBottom="10">
              Latest articles
            </Heading>
            <Link href="/create">
              <Button variant="primary-button">Create</Button>
            </Link>
          </Flex>
          <SimpleGrid
            templateColumns={{
              base: "repeat(1, 1fr)",
              lg: "repeat(6, 1fr)",
            }}
            spacing="40px"
          >
            {!articleData &&
              [0, 1, 2].map((item) => {
                return (
                  <GridItem colSpan={{ base: 6, lg: 2 }} key={item}>
                    <Wrap spacing="30px" marginBottom="10">
                      <WrapItem
                        width={{ base: "100%", sm: "100%", md: "100%", lg: "100%" }}
                      >
                        <Box w="100%" height="100%">
                          <Box borderRadius="lg" overflow="hidden">
                            <Box
                              textDecoration="none"
                              _hover={{ textDecoration: "none" }}
                            >
                              <Skeleton colorScheme="purple">
                                <div
                                  style={{ borderRadius: "10px", height: "400px" }}
                                />
                              </Skeleton>
                            </Box>
                          </Box>
                        </Box>
                      </WrapItem>
                    </Wrap>
                  </GridItem>
                );
              })}
            {articleData &&
              articleData.map((item, index) => {
                return (
                  <GridItem colSpan={{ base: 6, lg: 2 }} key={index}>
                    <Wrap spacing="30px" marginBottom="10">
                      <WrapItem
                        width={{ base: "100%", sm: "100%", md: "100%", lg: "100%" }}
                      >
                        <Box w="100%" height="100%">
                          <Box borderRadius="lg" overflow="hidden">
                            <Box
                              textDecoration="none"
                              _hover={{ textDecoration: "none" }}
                            >
                              <Link href={`/${item.slug}`}>
                                <Image
                                  transform="scale(1.0)"
                                  src={item.thumbnail}
                                  alt="some text"
                                  objectFit="contain"
                                  width="100%"
                                  transition="0.3s ease-in-out"
                                  _hover={{
                                    transform: "scale(1.05)",
                                  }}
                                />
                              </Link>
                            </Box>
                          </Box>
                          <BlogTags tags={item.tags} marginTop={3} />
                          <Heading fontSize="xl" marginTop="2">
                            <Link href={`/${item.slug}`}>
                              <Text
                                textDecoration="none"
                                _hover={{ textDecoration: "none" }}
                              >
                                {item.title}
                              </Text>
                            </Link>
                          </Heading>
                          <Text as="p" fontSize="md" marginTop="2">
                            {item.description}
                          </Text>
                        </Box>
                      </WrapItem>
                    </Wrap>
                  </GridItem>
                );
              })}
          </SimpleGrid>
        </Box>
      );
    };
    export default ArticleList;
```

We are here using the useEffect hook to call the `getArticle()` function that fetches the article data. In the return section, we are displaying the article. On completion, this route will look like this:

![Home Page](https://paper-attachments.dropboxusercontent.com/s_A1F14CB9F9D9154D0EBE8EC24C80324C8F0438DE22B4D8CBB6325295C0479B1E_1713425161623_image.png)

# Create Route

Create a directory in the app directory with the name create. This route will be useful in creating the article. Here we have 4 files.

```
    --page.js     // page will be rendered. 
    --ArticleSetting.js     // it will contain data such as title, description, tags, etc.
    --WriteArticle.js     // it used to put the markdown version of the article.
    --tagOption.js     // this file contain the tag option that can be selected.
```

All the files are quite big in terms of lines of code. So rather than putting it all here. You can look into it from the GitHub repository [here](https://github.com/surajondev/supabase-blog). Some interesting pieces of code that we can discuss from these routes are:

## Uploading Image to Storage

```jsx
    <FormControl>
      <Input
        variant={"form-input-file"}
        name="thumbnail"
        type="file"
        onChange={async (e) => {
          const timestamp = Date.now();
          const { data, error } = await supabase.storage
            .from("thumbnail")
            .upload(`${timestamp}-${e.target.files[0].name}`, e.target.files[0], {
              cacheControl: "3600",
              upsert: false,
            });
          if (error) {
            console.log(error);
            return;
          }
          const path = data.path.replace(/ /g, "%20");
          const SUPABASE_REFERENCE = "hkvyihwfkphuwgetdtee";
          const URL = `https://${SUPABASE_REFERENCE}.supabase.co/storage/v1/object/public/thumbnail/${path}`;
          setImgURL(URL);
          setFieldValue("thumbnail", URL);
        }}
        onBlur={handleBlur}
      />
    </FormControl>;
```    

Here you see, we have used the Input component from Chakra UI to get the image and on every change, we are uploading the image to the bucket in the Supabase. You can get `SUPABASE_REFERENCE` from the Dashboard→ Setting from the Supabase. 

## Rendering Markdown

```jsx
    const PreviewArticle = ({ contentMarkdown }) => {
      return (
        <Box>
          {/* @ts-ignore */}
          <Markdown components={ChakraUIRenderer(MarkdownTheme)} skipHtml>
            {contentMarkdown}
          </Markdown>
        </Box>
      );
    };
```

This is in the `WriteArticle.js` It is used to render the Markdown into HTML element. The `MarkdownTheme` is provided in the theme directory in the route. Here is the code for it.

```jsx
    import { Text, Heading, Link, Code, ListItem, UnorderedList } from '@chakra-ui/react';
    
    const MarkdownTheme = {
        p: (props) => {
          const { children } = props;
          return (
            <Text  variant={"secondary-text"} lineHeight={2} p="0.5em 0">
              {children}
            </Text>
          );
        },
        h1: (props) => {
          const { children } = props;
          return (
            <Heading  variant={"secondary-heading"} lineHeight={2}>
              {children}
            </Heading>
          );
        },
        h2: (props) => {
          const { children } = props;
          return (
            <Heading  variant={"secondary-heading"} lineHeight={2}>
              {children}
            </Heading>
          );
        },
        a: (props) => {
          const { href, children } = props;
          return (
            <Link href={href} variant={"secondary-text"} textDecoration="underline" cursor="pointer" fontWeight="bold" lineHeight={2}>{children}</Link>
          );
        },
        code: (props) => {
          const { children } = props;
          // console.log("props", props)
          console.log(children.includes("\n"))
          if(children.includes("\n")){
            return (
              <Code children={children} colorScheme='purple' width="100%" p="1em 1em"/>
            );
          }else{
            return (
              <a style={{backgroundColor:"lightgray", padding:"0 0.2em"}}>{children}</a>
            );
          }
        },
        li: (props) => {
          const { children } = props;
          return (
            <UnorderedList>
      <ListItem><Text  variant={"secondary-text"} lineHeight={2}>
              {children}
            </Text></ListItem>
    </UnorderedList>
          );
        },
      };
      
    export default MarkdownTheme;
```

In the above code, you can see how each HTML tag will be rendered as per the Chakra theme. You can refer to [Basic Syntax](https://www.markdownguide.org/basic-syntax/) Guide by MarkdownGuide to understand which Syntax is mapped to which HTML tag.

Overall here is the gif demonstrating this route functionality.

![Create Route](https://paper-attachments.dropboxusercontent.com/s_A1F14CB9F9D9154D0EBE8EC24C80324C8F0438DE22B4D8CBB6325295C0479B1E_1713428255892_localhost_3000_create+1.gif)

# /[slug]

This route is used to render the blog as an HTML page that can be viewed. Here are the two files: `page.js` will render a skeleton when loading and if the article is found then will display the article using the `DisplayArticle.jsx` component. Here is the code.

## page.js

```jsx
    const ArticlePage = () => {
      const [articleData, setArticleData] = useState(null);
      const router = useRouter();
      const pathname = usePathname();
      const handleFetchParam = async () => {
        const slugArr = pathname.split("/");
        const slug = slugArr[slugArr.length - 1];
        console.log(slug);
        const { data: articleData, error: artilceError } = await supabase
          .from("article")
          .select()
          .eq("slug", slug);
        if (artilceError) {
          console.log(artilceError);
        } else {
          setArticleData(articleData[0]);
          console.log(articleData[0]);
        }
      };
      useEffect(() => {
        handleFetchParam();
      }, []);
      return (
        <Box margin="0 auto">
          {!articleData && (
            <Stack
              spacing={10}
              margin="0 auto"
              marginTop={20}
              marginBottom={20}
              width={{
                xl: "60%",
                "2xl": "50%",
                lg: "70%",
                base: "100%",
                md: "80%",
              }}
            >
              {/* @ts-ignore */}
              <Skeleton colorScheme="purple">
                <div style={{ borderRadius: "10px", height: "300px" }} />
              </Skeleton>
              <Stack>
                <Skeleton colorScheme="purple">
                  <div style={{ borderRadius: "10px", height: "100px" }} />
                </Skeleton>
                <Skeleton colorScheme="purple">
                  <div style={{ borderRadius: "10px", height: "40px" }} />
                </Skeleton>
                <Skeleton colorScheme="purple">
                  <div style={{ borderRadius: "10px", height: "100px" }} />
                </Skeleton>
              </Stack>
              <Box>
                <Skeleton colorScheme="purple">
                  <div style={{ borderRadius: "10px", height: "600px" }} />
                </Skeleton>
              </Box>
            </Stack>
          )}
          <Box
            width={{ xl: "60%", "2xl": "50%", lg: "70%", base: "100%", md: "80%" }}
            margin="0 auto"
            marginBottom={40}
          >
            {articleData != null && <DisplayArticle articleData={articleData} />}
          </Box>
        </Box>
      );
    };
    export default ArticlePage;
```

The code is self-explanatory we are just rendering the loading skeleton then on getting the `articleData`, we are rendering the DisplayArticle component.

## DisplayArticle.jsx

```jsx
    export const DisplayArticle = ({ articleData }) => {
      console.log(articleData.markdown);
      return (
        <Stack width="80%" className="mainContainer" spacing={10} marginBottom={20}>
          {/* @ts-ignore */}
          <Image
            transform="scale(1.0)"
            src={articleData.thumbnail}
            alt="some text"
            objectFit="contain"
            width="100%"
            mt={20}
          />
          <Stack>
            <Heading variant="primary-variant">{articleData.title}</Heading>
            <BlogTags tags={articleData.tags} marginTop={3} />
          </Stack>
          <Box>
            <Markdown components={ChakraUIRenderer(MarkdownTheme)} skipHtml>
              {articleData.markdown}
            </Markdown>
          </Box>
        </Stack>
      );
    };
    const BlogAuthor = (props) => {
      return (
        <HStack marginTop="2" spacing="2" display="flex" alignItems="center">
          <Image
            borderRadius="full"
            boxSize="40px"
            src={props.image}
            alt={`Avatar of ${props.name}`}
          />
          <Text variant="secondary-text">{props.name}</Text>
          <Text>—</Text>
          <Text variant="secondary-text">{props.date}</Text>
        </HStack>
      );
    };
    const BlogTags = (props) => {
      const { marginTop = 0, tags } = props;
      return (
        <HStack spacing={2} marginTop={marginTop}>
          {tags.map((tag) => {
            return (
              <Tag size={"md"} variant="solid" colorScheme="orange" key={tag}>
                {tag}
              </Tag>
            );
          })}
        </HStack>
      );
    };
```

Here, you can see the screenshot of a rendered article.

![Rendered Article](https://paper-attachments.dropboxusercontent.com/s_A1F14CB9F9D9154D0EBE8EC24C80324C8F0438DE22B4D8CBB6325295C0479B1E_1713428565865_image.png)

# GitHub Repository

I have created the GitHub repository of the file. You can refer to that for the whole code at once if you want to recreate the project. 

Here is the link: https://github.com/surajondev/supabase-blog

# Conclusion

Building a Markdown-rendered blog with Supabase and Chakra UI offers an efficient way to create a dynamic, database-backed blogging platform. By combining Supabase for data storage and file handling with Chakra UI for stylish and responsive UI components, developers can quickly develop a feature-rich blog. 

This walkthrough demonstrates setting up routes, CRUD operations, markdown rendering, and image uploads using Next.js for enhanced routing and navigation. The GitHub repository provides a comprehensive guide for replicating and extending this project, enabling developers to customize and expand their own Markdown-powered blogs with ease, tailored to their specific needs and design preferences. This project serves as a practical example of integrating modern technologies to build a scalable and visually appealing blogging platform for content creators.

I hope this article has helped in understanding how to create a blog. Thanks for reading the article.