Build a Dynamic Sitemap Generator

// src/seo/sitemap-generator.ts — Dynamic sitemap with index and auto-submission
import { pool } from "../db";
import { Hono } from "hono";

const SITE_URL = process.env.SITE_URL || "https://example.com";
const MAX_URLS_PER_SITEMAP = 10000;  // Google recommends max 50K, we use 10K for speed

interface SitemapUrl {
  loc: string;
  lastmod?: string;
  changefreq?: "always" | "hourly" | "daily" | "weekly" | "monthly" | "yearly" | "never";
  priority?: number;          // 0.0 to 1.0
  images?: Array<{ loc: string; title?: string }>;
}

// Generate sitemap index (lists all sub-sitemaps)
export async function generateSitemapIndex(): Promise<string> {
  const sitemaps = [];

  // Static pages sitemap
  sitemaps.push({
    loc: `${SITE_URL}/sitemaps/static.xml`,
    lastmod: new Date().toISOString().slice(0, 10),
  });

  // Product sitemaps (paginated)
  const { rows: [{ count: productCount }] } = await pool.query("SELECT COUNT(*) as count FROM products WHERE active = true");
  const productPages = Math.ceil(parseInt(productCount) / MAX_URLS_PER_SITEMAP);
  for (let i = 1; i <= productPages; i++) {
    const { rows: [{ max_updated }] } = await pool.query(
      `SELECT MAX(updated_at)::date as max_updated FROM products WHERE active = true
       ORDER BY id LIMIT $1 OFFSET $2`,
      [MAX_URLS_PER_SITEMAP, (i - 1) * MAX_URLS_PER_SITEMAP]
    );
    sitemaps.push({
      loc: `${SITE_URL}/sitemaps/products-${i}.xml`,
      lastmod: max_updated || new Date().toISOString().slice(0, 10),
    });
  }

  // Blog sitemap
  sitemaps.push({
    loc: `${SITE_URL}/sitemaps/blog.xml`,
    lastmod: new Date().toISOString().slice(0, 10),
  });

  // Category sitemap
  sitemaps.push({
    loc: `${SITE_URL}/sitemaps/categories.xml`,
    lastmod: new Date().toISOString().slice(0, 10),
  });

  return buildSitemapIndex(sitemaps);
}

// Generate product sitemap page
export async function generateProductSitemap(page: number): Promise<string> {
  const offset = (page - 1) * MAX_URLS_PER_SITEMAP;

  const { rows: products } = await pool.query(
    `SELECT slug, updated_at, image_url, name FROM products
     WHERE active = true
     ORDER BY id
     LIMIT $1 OFFSET $2`,
    [MAX_URLS_PER_SITEMAP, offset]
  );

  const urls: SitemapUrl[] = products.map((p) => ({
    loc: `${SITE_URL}/products/${p.slug}`,
    lastmod: new Date(p.updated_at).toISOString().slice(0, 10),
    changefreq: "weekly" as const,
    priority: 0.8,
    images: p.image_url ? [{ loc: p.image_url, title: p.name }] : [],
  }));

  return buildUrlSet(urls);
}

// Generate blog sitemap
export async function generateBlogSitemap(): Promise<string> {
  const { rows: posts } = await pool.query(
    "SELECT slug, updated_at, published_at FROM blog_posts WHERE status = 'published' ORDER BY published_at DESC"
  );

  const urls: SitemapUrl[] = posts.map((p) => ({
    loc: `${SITE_URL}/blog/${p.slug}`,
    lastmod: new Date(p.updated_at).toISOString().slice(0, 10),
    changefreq: "monthly" as const,
    priority: 0.6,
  }));

  return buildUrlSet(urls);
}

// Generate static pages sitemap
export async function generateStaticSitemap(): Promise<string> {
  const urls: SitemapUrl[] = [
    { loc: SITE_URL, changefreq: "daily", priority: 1.0 },
    { loc: `${SITE_URL}/about`, changefreq: "monthly", priority: 0.5 },
    { loc: `${SITE_URL}/pricing`, changefreq: "weekly", priority: 0.9 },
    { loc: `${SITE_URL}/contact`, changefreq: "monthly", priority: 0.4 },
    { loc: `${SITE_URL}/blog`, changefreq: "daily", priority: 0.7 },
    { loc: `${SITE_URL}/products`, changefreq: "daily", priority: 0.9 },
  ];

  return buildUrlSet(urls);
}

// XML builders
function buildSitemapIndex(sitemaps: Array<{ loc: string; lastmod: string }>): string {
  const entries = sitemaps.map((s) => `  <sitemap>
    <loc>${escapeXml(s.loc)}</loc>
    <lastmod>${s.lastmod}</lastmod>
  </sitemap>`).join("\n");

  return `<?xml version="1.0" encoding="UTF-8"?>
<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
${entries}
</sitemapindex>`;
}

function buildUrlSet(urls: SitemapUrl[]): string {
  const entries = urls.map((u) => {
    let xml = `  <url>\n    <loc>${escapeXml(u.loc)}</loc>`;
    if (u.lastmod) xml += `\n    <lastmod>${u.lastmod}</lastmod>`;
    if (u.changefreq) xml += `\n    <changefreq>${u.changefreq}</changefreq>`;
    if (u.priority !== undefined) xml += `\n    <priority>${u.priority.toFixed(1)}</priority>`;
    if (u.images?.length) {
      for (const img of u.images) {
        xml += `\n    <image:image>\n      <image:loc>${escapeXml(img.loc)}</image:loc>`;
        if (img.title) xml += `\n      <image:title>${escapeXml(img.title)}</image:title>`;
        xml += `\n    </image:image>`;
      }
    }
    xml += `\n  </url>`;
    return xml;
  }).join("\n");

  return `<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"
        xmlns:image="http://www.google.com/schemas/sitemap-image/1.1">
${entries}
</urlset>`;
}

function escapeXml(str: string): string {
  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
}

// Ping search engines after sitemap update
export async function pingSearchEngines(): Promise<void> {
  const sitemapUrl = `${SITE_URL}/sitemap.xml`;
  await Promise.allSettled([
    fetch(`https://www.google.com/ping?sitemap=${encodeURIComponent(sitemapUrl)}`),
    fetch(`https://www.bing.com/ping?sitemap=${encodeURIComponent(sitemapUrl)}`),
  ]);
}

// Routes
const app = new Hono();

app.get("/sitemap.xml", async (c) => {
  const xml = await generateSitemapIndex();
  return c.body(xml, { headers: { "Content-Type": "application/xml", "Cache-Control": "public, max-age=3600" } });
});

app.get("/sitemaps/static.xml", async (c) => {
  const xml = await generateStaticSitemap();
  return c.body(xml, { headers: { "Content-Type": "application/xml" } });
});

app.get("/sitemaps/products-:page.xml", async (c) => {
  const page = parseInt(c.req.param("page"));
  const xml = await generateProductSitemap(page);
  return c.body(xml, { headers: { "Content-Type": "application/xml" } });
});

app.get("/sitemaps/blog.xml", async (c) => {
  const xml = await generateBlogSitemap();
  return c.body(xml, { headers: { "Content-Type": "application/xml" } });
});

export default app;