Episode 10: The Great Pre-Render Mission – Arin’s Quest for Custom SSR and SSG Mastery

#webdev #javascript #tutorial #react

Episode 10: The Great Pre-Render Mission – Arin’s Quest for Custom SSR and SSG Mastery

The Static Vaults of Codex glimmered with quiet anticipation. These vaults were the silent guardians of knowledge, their walls lined with data scrolls and glowing pages that awaited the Users' summons. Today, Arin stood at the threshold of these vaults, tasked with mastering a new and essential craft: creating static pre-rendered pages that would help Codex serve its Users faster than ever before.

“Arin,” Captain Lifecycle’s voice resonated through the vaulted chamber, drawing her focus. “Today, you’ll learn to harness the power of static rendering. This isn’t just about knowledge—it’s about preparing Codex to meet the Users’ needs before they even arise.”

A challenge worthy of a true defender, Arin thought, determination lighting her eyes. It was time to craft a system that would allow Codex to pre-render its pages, ensuring instantaneous response when called upon.

1. Crafting the Archives – Building Custom SSG with MDX

Captain Lifecycle walked alongside Arin as she moved deeper into the Vaults. Scrolls illuminated with data, revealing scripts and pages rendered long before a User needed them. “To prepare Codex, we must learn to capture knowledge and store it in these pages,” he said.

Arin’s task was clear: build a static site generation (SSG) system for Codex’s blog, where the stories and lessons of the past could be summoned at a moment’s notice.

Step 1: Gathering the Tools
The first step was to equip Codex with the means to read and compile its scrolls—MDX files.

npm install fs-extra react react-dom react-dom/server @mdx-js/react @mdx-js/mdx

The chamber buzzed softly as Arin activated the components. Each installation was like a rune etched into the vault’s infrastructure, preparing it to interpret and render the ancient texts.

Step 2: Writing the First MDX Scroll
Arin picked up a quill and began composing Codex’s first blog, a tale of its history woven with interactive React components.

// blogs/hello-world.mdx
# Hello, World!

Welcome to Codex’s first blog post. This content is rendered from an MDX file, combining the simplicity of Markdown with the power of React components.

<SpecialNote>This is a special React component embedded within MDX!</SpecialNote>

With each stroke, the page glowed, its contents now a blend of simple text and complex components.

Step 3: Creating the Script to Render the Scrolls
Arin crafted a spell—a script—that would read the scrolls, compile them into React components, and render them as static HTML.

// generateStaticBlogs.js
const fs = require('fs-extra');
const path = require('path');
const React = require('react');
const ReactDOMServer = require('react-dom/server');
const { MDXProvider } = require('@mdx-js/react');
const mdx = require('@mdx-js/mdx');

const outputPath = './static-blogs';
const blogPath = './blogs';

(async () => {
  try {
    // Ensure the output directory exists
    await fs.ensureDir(outputPath);

    const blogFiles = await fs.readdir(blogPath);
    for (const file of blogFiles) {
      if (path.extname(file) === '.mdx') {
        const filePath = path.join(blogPath, file);
        const content = await fs.readFile(filePath, 'utf8');
        const compiledMdx = await mdx(content);
        const Component = new Function('React', compiledMdx)(React);

        // Render the component to a static HTML string
        const renderedBlog = ReactDOMServer.renderToString(
          <MDXProvider>
            <Component />
          </MDXProvider>
        );

        const htmlTemplate = `
          <!DOCTYPE html>
          <html lang="en">
            <head>
              <meta charset="UTF-8" />
              <meta name="viewport" content="width=device-width, initial-scale=1.0" />
              <title>${path.basename(file, '.mdx')}</title>
            </head>
            <body>
              <div id="root">${renderedBlog}</div>
            </body>
          </html>
        `;

        // Write the rendered HTML to a file
        await fs.writeFile(`${outputPath}/${path.basename(file, '.mdx')}.html`, htmlTemplate);
        console.log(`Static blog page for ${file} generated successfully!`);
      }
    }
  } catch (error) {
    console.error('Error generating static blogs:', error);
  }
})();

Step 4: Running the Spell
Arin murmured the incantation to invoke the script.

node generateStaticBlogs.js

She watched as the Static Vaults came to life, each blog glowing softly as it transformed into a static page ready to be served to the Users.

Arin’s Reflection:
“These static pages are more than just echoes,” she thought, watching the vaults shimmer with knowledge. “They are Codex’s readiness to serve, instant and unwavering.”

2. The Pros and Cons of Static Preparedness

Captain Lifecycle’s voice cut through the air. “Remember, Arin, while static pages are powerful, they come with their own trade-offs.”

Pros:

Blazing Fast Load Times: Pre-rendered pages are served instantly, giving Users the illusion of seamless speed.
SEO Mastery: Fully rendered HTML ensures that Codex’s stories are well-indexed, gaining visibility.
Developer-Friendly: MDX allows rich React components to live side-by-side with Markdown, blending simplicity with interactivity.

Cons:

Rebuilds: Codex’s pages must be rebuilt for updates, making dynamic content harder to manage.
Initial Build Time: Large archives of content can take time to generate.

“It’s like crafting an archive, Arin,” Captain Lifecycle said, “one that must be tended to and updated as new stories are written.”

3. Incremental Static Regeneration – The Adaptive Keeper

“But Captain,” Arin’s brow furrowed as she thought, “what if Codex needs to refresh its stories without rewriting everything?”

Captain Lifecycle nodded. “That’s where Incremental Static Regeneration comes in. It’s a keeper that updates content as needed, keeping the pages fresh without remaking the entire archive.”

Example of Scheduled ISR with Node-Cron:
To keep pages up-to-date, Arin introduced a guardian spell that would run at set intervals.

npm install node-cron

const cron = require('node-cron');

cron.schedule('0 * * * *', () => {
  console.log('Regenerating static pages...');
  require('./generateStaticBlogs');
});

console.log('Scheduled ISR running every hour.');

Arin’s Insight:
“With ISR, Codex doesn’t just react—it adapts,” she thought, feeling a sense of readiness. “The Users will always find Codex up-to-date, prepared to guide them.”

Conclusion: Beyond the Mission

The Vaults stood serene and glowing with the knowledge that Arin had woven into them. Captain Lifecycle placed a hand on her shoulder, pride evident in his eyes. “You’ve learned to pre-render Codex’s essence. But remember, there are tools beyond our realm that make this even easier.”

Arin nodded, understanding the path ahead. “For Codex, for the Users, we prepare, adapt, and always serve.”

Important Note for Readers:

The examples provided here are fundamental approaches to understanding custom SSR and SSG. For production-level applications, look into frameworks like Next.js, Remix, and Astro that offer optimized, secure, and scalable solutions for pre-rendering.