Build a Sitemap Generator

// src/seo/sitemap.ts — Automated sitemap generation with priority, hreflang, and images
import { pool } from "../db";
import { Redis } from "ioredis";
import { createHash } from "node:crypto";

const redis = new Redis(process.env.REDIS_URL!);

interface SitemapURL {
  loc: string;
  lastmod: string;
  changefreq: "always" | "hourly" | "daily" | "weekly" | "monthly" | "yearly" | "never";
  priority: number;          // 0.0-1.0
  images?: Array<{ loc: string; title?: string; caption?: string }>;
  alternates?: Array<{ hreflang: string; href: string }>;  // multi-language
}

interface SitemapConfig {
  baseUrl: string;
  maxUrlsPerSitemap: number;  // Google limit: 50,000
  languages: string[];
  excludePatterns: string[];
}

const DEFAULT_CONFIG: SitemapConfig = {
  baseUrl: process.env.SITE_URL || "https://example.com",
  maxUrlsPerSitemap: 45000,  // leave buffer below 50K limit
  languages: ["en", "es", "fr", "de"],
  excludePatterns: ["/admin", "/api", "/internal", "/_next"],
};

// Generate complete sitemap
export async function generateSitemap(config?: Partial<SitemapConfig>): Promise<{
  sitemapIndex: string;
  sitemaps: Array<{ name: string; xml: string; urlCount: number }>;
}> {
  const cfg = { ...DEFAULT_CONFIG, ...config };

  // Collect all URLs
  const urls = await collectURLs(cfg);

  // Split into chunks (max 45K per sitemap)
  const chunks: SitemapURL[][] = [];
  for (let i = 0; i < urls.length; i += cfg.maxUrlsPerSitemap) {
    chunks.push(urls.slice(i, i + cfg.maxUrlsPerSitemap));
  }

  // Generate XML for each chunk
  const sitemaps = chunks.map((chunk, i) => {
    const name = chunks.length === 1 ? "sitemap.xml" : `sitemap-${i + 1}.xml`;
    return { name, xml: generateSitemapXML(chunk), urlCount: chunk.length };
  });

  // Generate sitemap index
  const sitemapIndex = generateSitemapIndexXML(cfg.baseUrl, sitemaps.map((s) => s.name));

  // Cache sitemaps
  for (const sm of sitemaps) {
    await redis.setex(`sitemap:${sm.name}`, 3600, sm.xml);
  }
  await redis.setex("sitemap:index", 3600, sitemapIndex);

  return { sitemapIndex, sitemaps };
}

async function collectURLs(config: SitemapConfig): Promise<SitemapURL[]> {
  const urls: SitemapURL[] = [];

  // Products
  const { rows: products } = await pool.query(
    "SELECT slug, updated_at, images, price FROM products WHERE status = 'active' ORDER BY updated_at DESC"
  );
  for (const p of products) {
    const images = JSON.parse(p.images || "[]");
    const productUrl: SitemapURL = {
      loc: `${config.baseUrl}/products/${p.slug}`,
      lastmod: new Date(p.updated_at).toISOString().slice(0, 10),
      changefreq: detectChangeFreq(p.updated_at),
      priority: calculatePriority("product", p),
      images: images.slice(0, 10).map((img: string) => ({ loc: img, title: p.slug })),
      alternates: config.languages.map((lang) => ({
        hreflang: lang,
        href: `${config.baseUrl}/${lang}/products/${p.slug}`,
      })),
    };
    urls.push(productUrl);
  }

  // Blog posts
  const { rows: posts } = await pool.query(
    "SELECT slug, updated_at, featured_image, views FROM blog_posts WHERE status = 'published' ORDER BY updated_at DESC"
  );
  for (const p of posts) {
    urls.push({
      loc: `${config.baseUrl}/blog/${p.slug}`,
      lastmod: new Date(p.updated_at).toISOString().slice(0, 10),
      changefreq: detectChangeFreq(p.updated_at),
      priority: calculatePriority("blog", p),
      images: p.featured_image ? [{ loc: p.featured_image }] : [],
      alternates: config.languages.map((lang) => ({
        hreflang: lang,
        href: `${config.baseUrl}/${lang}/blog/${p.slug}`,
      })),
    });
  }

  // Categories
  const { rows: categories } = await pool.query(
    "SELECT slug, updated_at, product_count FROM categories WHERE product_count > 0"
  );
  for (const c of categories) {
    urls.push({
      loc: `${config.baseUrl}/categories/${c.slug}`,
      lastmod: new Date(c.updated_at).toISOString().slice(0, 10),
      changefreq: "weekly",
      priority: Math.min(0.8, 0.5 + (c.product_count / 100) * 0.3),
    });
  }

  // Static pages
  const staticPages = [
    { loc: "/", priority: 1.0, changefreq: "daily" as const },
    { loc: "/about", priority: 0.5, changefreq: "monthly" as const },
    { loc: "/contact", priority: 0.5, changefreq: "monthly" as const },
    { loc: "/pricing", priority: 0.8, changefreq: "weekly" as const },
  ];
  for (const page of staticPages) {
    urls.push({
      loc: `${config.baseUrl}${page.loc}`,
      lastmod: new Date().toISOString().slice(0, 10),
      changefreq: page.changefreq,
      priority: page.priority,
    });
  }

  // Filter excluded patterns
  return urls.filter((u) => !config.excludePatterns.some((p) => u.loc.includes(p)));
}

function calculatePriority(type: string, data: any): number {
  switch (type) {
    case "product": {
      let priority = 0.6;
      if (data.price > 100) priority += 0.1;  // high-value products
      const daysSinceUpdate = (Date.now() - new Date(data.updated_at).getTime()) / 86400000;
      if (daysSinceUpdate < 7) priority += 0.1;  // recently updated
      return Math.min(0.9, priority);
    }
    case "blog": {
      let priority = 0.5;
      if (data.views > 1000) priority += 0.2;  // popular content
      return Math.min(0.8, priority);
    }
    default: return 0.5;
  }
}

function detectChangeFreq(updatedAt: string): SitemapURL["changefreq"] {
  const days = (Date.now() - new Date(updatedAt).getTime()) / 86400000;
  if (days < 1) return "daily";
  if (days < 7) return "weekly";
  if (days < 30) return "monthly";
  return "yearly";
}

function generateSitemapXML(urls: SitemapURL[]): string {
  const entries = urls.map((u) => {
    let xml = `  <url>\n    <loc>${escapeXml(u.loc)}</loc>\n    <lastmod>${u.lastmod}</lastmod>\n    <changefreq>${u.changefreq}</changefreq>\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>`;
      }
    }

    if (u.alternates?.length) {
      for (const alt of u.alternates) {
        xml += `\n    <xhtml:link rel="alternate" hreflang="${alt.hreflang}" href="${escapeXml(alt.href)}" />`;
      }
    }

    xml += `\n  </url>`;
    return xml;
  }).join("\n");

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

function generateSitemapIndexXML(baseUrl: string, sitemapNames: string[]): string {
  const entries = sitemapNames.map((name) =>
    `  <sitemap>\n    <loc>${baseUrl}/${name}</loc>\n    <lastmod>${new Date().toISOString().slice(0, 10)}</lastmod>\n  </sitemap>`
  ).join("\n");
  return `<?xml version="1.0" encoding="UTF-8"?>\n<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n${entries}\n</sitemapindex>`;
}

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

// Ping search engines after sitemap update
export async function pingSearchEngines(sitemapUrl: string): Promise<Record<string, boolean>> {
  const engines = [
    { name: "Google", url: `https://www.google.com/ping?sitemap=${encodeURIComponent(sitemapUrl)}` },
    { name: "Bing", url: `https://www.bing.com/ping?sitemap=${encodeURIComponent(sitemapUrl)}` },
  ];

  const results: Record<string, boolean> = {};
  for (const engine of engines) {
    try {
      const resp = await fetch(engine.url, { signal: AbortSignal.timeout(5000) });
      results[engine.name] = resp.ok;
    } catch {
      results[engine.name] = false;
    }
  }
  return results;
}