Back in June last year I added an RSS feed to the website so people could 
[subscribe](https://www.liam-reilly.info/blog/post/subscribe-rss) and keep up to date with my latest blog posts. Ever 
since then I've been manually updating the RSS feed and adding in each new blog post. Yuck! Today I finally automated this. 

The first thing I needed to do was construct an XML file. I used a library for this called 
[object-to-xml](https://www.npmjs.com/package/object-to-xml). This allowed me to construct the main part of the RSS 
document `<channel>`. 

```javascript
const channelObj= {
    channel: {
        title: "liam-reilly.info",
        link: "https://www.liam-reilly.info/",
        description: "Random updates, usually something I'm reading or thinking...",
        docs: "https://validator.w3.org/feed/docs/rss2.html",
        language: "en-GB",
        copyright: "© Liam Reilly",
        "atom:link": {
            "@": {
                href: "https://www.liam-reilly.info/feed.xml",
                rel: "self",
                type: "application/rss+xml"
            }
        },
        image: {
            url: "https://www.liam-reilly.info/assets/favicons/liam-reilly-info.png",
            title: "liam-reilly.info",
            link: "https://www.liam-reilly.info/"
        },
        webMaster: "admin@liam-reilly.info",
        lastBuildDate: getDateTime(), // (this function returns current date and time in format YYYY-MM-DDTHH-MM-SS
    }
}
```

Next I needed to convert the channel object to XML, wrap with the `<rss>` elements and write out a file.

```javascript
const o2x = require("object-to-xml")

const feedFile = "public/feed.xml"

const rssRootStart = '<rss xmlns:atom="http://www.w3.org/2005/Atom" version="2.0">'
const rssRootEnd = '</rss>'

const channel = o2x(channelObj)
const rss = `${rssRootStart}${channel}${rssRootEnd}`

fs.writeFile(feedFile, rss, (err => {
    if (err) console.log(err)
}));
```

So far so good, but it's pretty useless without any blog posts!

The blog posts on my website are actually [Markdown](https://www.markdownguide.org/) files. Each file consists of two parts.
At the top of each file I have metadata which is expressed as [YAML](https://yaml.org/) and is known as 
[Front Matter](https://assemble.io/docs/YAML-front-matter.html). I define many key pieces of information here such as the
title of the post, the date it was written, [Open Graph](https://ogp.me/) data and even affiliate links that relate to the post.

Below the metadata lives the content. All blog post content is written in Markdown format which is later converted to HTML on the fly,
as each post is rendered.

I have the following methods that read my blog posts directory.

```javascript
const fs = require("fs")
const path = require("path")
const matter = require("gray-matter")

const getAllPosts = (postsDirectory, fields = []) => {
    const slugs = getPostSlugs(postsDirectory)

    return slugs
        .map(slug => getPostBySlug(postsDirectory, slug, fields))
        .sort((post1, post2) => (post1.date > post2.date ? -1 : 1))
}

const getPostSlugs = (postsDirectory) => {
    return fs.readdirSync(postsDirectory)
}

const getPostBySlug = (postsDirectory, slug, fields = []) => {
    const realSlug = slug.replace(/\.md$/, '')
    const fullPath = path.join(postsDirectory, `${realSlug}.md`)
    const fileContents = fs.readFileSync(fullPath, 'utf8')
    const { data, content } = matter(fileContents)

    const items = {}

    fields.forEach((field) => {
        if (field === 'slug') {
            items[field] = realSlug
        }
        if (field === 'content') {
            items[field] = content
        }
        if (data[field]) {
            items[field] = data[field]
        }
    })

    return items
}
```

The next step is to get all blog posts, including any metadata that is needed to make up each `<item>` in the RSS feed.
Remember that the `content` of each blog post is Markdown and not HTML, so I use a library called `markdown-js` to 
convert the Markdown content to HTML.

```javascript
const markdown = require("markdown-js")

const buildItems = () => {
    const posts = getAllPosts(`public/blog`, [
        "title",
        "og",
        "date",
        "content"
    ])

    let items = []

    posts.map(p => items.push(buildItem(
        p.title,
        p.og["url"],
        p.date,
        markdown.makeHtml(p.content)
    )))

    return items
}

const buildItem = (title, link, pubDate, description) => ({
    title: title,
    link: link,
    guid: link,
    pubDate: pubDate,
    description: `<![CDATA[
        ${description}
    ]]>`,
})
```

The next step is to add this to our original piece of code that builds the `<channel>` object.

```javascript
const channelObj= {
    channel: {
        title: "liam-reilly.info",
        link: "https://www.liam-reilly.info/",
        description: "Random updates, usually something I'm reading or thinking...",
        docs: "https://validator.w3.org/feed/docs/rss2.html",
        language: "en-GB",
        copyright: "© Liam Reilly",
        "atom:link": {
            "@": {
                href: "https://www.liam-reilly.info/feed.xml",
                rel: "self",
                type: "application/rss+xml"
            }
        },
        image: {
            url: "https://www.liam-reilly.info/assets/favicons/liam-reilly-info.png",
            title: "liam-reilly.info",
            link: "https://www.liam-reilly.info/"
        },
        webMaster: "admin@liam-reilly.info",
        lastBuildDate: getDateTime(),
        item: buildItems() // <-- Adds the full array of blog post items
    }
}
```

That's it. I added it to the scripts section in `package.json`. 

```json
"scripts": {
  ...
  "build-rss": "node generate-rss.js"
}
```

Now I just need to run `npm run build-rss` before I publish a new blog post and moments later my rss `feed.xml` 
is rebuilt. Pretty 😎

I just wish I'd done this sooner 🤦‍♂️



AUTO GENERATE RSS