Build a Link Preview Generator

// src/preview/unfurler.ts — Link preview with OG extraction, fallbacks, and caching
import { Redis } from "ioredis";
import { createHash } from "node:crypto";

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

interface LinkPreview {
  url: string;
  title: string;
  description: string;
  image: string | null;
  favicon: string | null;
  siteName: string;
  type: string;                // "article" | "video" | "website" | "image"
  domain: string;
  author: string | null;
  publishedDate: string | null;
  videoUrl: string | null;
  embedHtml: string | null;    // for YouTube, Twitter, etc.
  contentType: string;
  fetchedAt: string;
}

const MAX_FETCH_TIME = 5000;   // 5s timeout
const MAX_HTML_SIZE = 512000;  // 500KB max
const CACHE_TTL = 86400 * 7;   // 7 days

// Known embed providers
const EMBED_PROVIDERS: Record<string, (url: URL) => string | null> = {
  "youtube.com": (url) => {
    const id = url.searchParams.get("v") || url.pathname.split("/").pop();
    return id ? `<iframe src="https://www.youtube.com/embed/${id}" frameborder="0" allowfullscreen></iframe>` : null;
  },
  "youtu.be": (url) => {
    const id = url.pathname.slice(1);
    return id ? `<iframe src="https://www.youtube.com/embed/${id}" frameborder="0" allowfullscreen></iframe>` : null;
  },
  "twitter.com": () => null, // use Twitter oEmbed API
  "x.com": () => null,
  "vimeo.com": (url) => {
    const id = url.pathname.split("/").pop();
    return id ? `<iframe src="https://player.vimeo.com/video/${id}" frameborder="0" allowfullscreen></iframe>` : null;
  },
};

// Get link preview with caching
export async function getPreview(url: string): Promise<LinkPreview> {
  // Validate URL
  let parsed: URL;
  try {
    parsed = new URL(url);
    if (!["http:", "https:"].includes(parsed.protocol)) throw new Error("Invalid protocol");
  } catch {
    throw new Error("Invalid URL");
  }

  // Block private IPs (SSRF prevention)
  if (isPrivateIP(parsed.hostname)) {
    throw new Error("Private URLs not allowed");
  }

  // Check cache
  const cacheKey = `preview:${createHash("md5").update(url).digest("hex")}`;
  const cached = await redis.get(cacheKey);
  if (cached) return JSON.parse(cached);

  // Check if it's a direct image
  if (/\.(jpg|jpeg|png|gif|webp|svg)(\?|$)/i.test(parsed.pathname)) {
    const preview: LinkPreview = {
      url, title: parsed.pathname.split("/").pop() || url,
      description: "", image: url, favicon: null,
      siteName: parsed.hostname, type: "image",
      domain: parsed.hostname, author: null, publishedDate: null,
      videoUrl: null, embedHtml: null, contentType: "image",
      fetchedAt: new Date().toISOString(),
    };
    await redis.setex(cacheKey, CACHE_TTL, JSON.stringify(preview));
    return preview;
  }

  // Fetch the page
  const controller = new AbortController();
  const timeout = setTimeout(() => controller.abort(), MAX_FETCH_TIME);

  try {
    const response = await fetch(url, {
      headers: {
        "User-Agent": "Mozilla/5.0 (compatible; LinkPreviewBot/1.0)",
        "Accept": "text/html,application/xhtml+xml",
        "Accept-Language": "en-US,en;q=0.9",
      },
      redirect: "follow",
      signal: controller.signal,
    });

    clearTimeout(timeout);

    const contentType = response.headers.get("content-type") || "";

    // Handle non-HTML (PDFs, images, etc.)
    if (!contentType.includes("html")) {
      const preview: LinkPreview = {
        url, title: decodeURIComponent(parsed.pathname.split("/").pop() || url),
        description: `${contentType} file`, image: null, favicon: null,
        siteName: parsed.hostname, type: "website", domain: parsed.hostname,
        author: null, publishedDate: null, videoUrl: null, embedHtml: null,
        contentType, fetchedAt: new Date().toISOString(),
      };
      await redis.setex(cacheKey, CACHE_TTL, JSON.stringify(preview));
      return preview;
    }

    const html = await response.text();
    const truncatedHtml = html.slice(0, MAX_HTML_SIZE);

    // Extract metadata
    const preview = extractMetadata(truncatedHtml, url, parsed);

    // Check for embed
    const embedDomain = Object.keys(EMBED_PROVIDERS).find((d) => parsed.hostname.endsWith(d));
    if (embedDomain) {
      preview.embedHtml = EMBED_PROVIDERS[embedDomain](parsed);
      if (preview.embedHtml) preview.type = "video";
    }

    // Resolve relative image URLs
    if (preview.image && !preview.image.startsWith("http")) {
      preview.image = new URL(preview.image, url).href;
    }

    // Get favicon
    preview.favicon = extractFavicon(truncatedHtml, url) || `https://www.google.com/s2/favicons?domain=${parsed.hostname}&sz=32`;

    await redis.setex(cacheKey, CACHE_TTL, JSON.stringify(preview));
    return preview;
  } catch (err: any) {
    clearTimeout(timeout);
    // Return minimal preview on failure
    const fallback: LinkPreview = {
      url, title: parsed.hostname, description: "",
      image: null, favicon: `https://www.google.com/s2/favicons?domain=${parsed.hostname}&sz=32`,
      siteName: parsed.hostname, type: "website", domain: parsed.hostname,
      author: null, publishedDate: null, videoUrl: null, embedHtml: null,
      contentType: "unknown", fetchedAt: new Date().toISOString(),
    };
    await redis.setex(cacheKey, 3600, JSON.stringify(fallback)); // shorter cache for failures
    return fallback;
  }
}

function extractMetadata(html: string, url: string, parsed: URL): LinkPreview {
  const get = (patterns: RegExp[]): string => {
    for (const p of patterns) {
      const match = html.match(p);
      if (match?.[1]) return decodeHtmlEntities(match[1].trim());
    }
    return "";
  };

  const title = get([
    /property="og:title"\s+content="([^"]+)"/i,
    /name="twitter:title"\s+content="([^"]+)"/i,
    /<title[^>]*>([^<]+)<\/title>/i,
  ]);

  const description = get([
    /property="og:description"\s+content="([^"]+)"/i,
    /name="twitter:description"\s+content="([^"]+)"/i,
    /name="description"\s+content="([^"]+)"/i,
  ]);

  const image = get([
    /property="og:image"\s+content="([^"]+)"/i,
    /name="twitter:image"\s+content="([^"]+)"/i,
    /name="twitter:image:src"\s+content="([^"]+)"/i,
  ]) || null;

  const siteName = get([/property="og:site_name"\s+content="([^"]+)"/i]) || parsed.hostname;
  const type = get([/property="og:type"\s+content="([^"]+)"/i]) || "website";
  const author = get([/name="author"\s+content="([^"]+)"/i]) || null;
  const publishedDate = get([
    /property="article:published_time"\s+content="([^"]+)"/i,
    /name="date"\s+content="([^"]+)"/i,
  ]) || null;

  return {
    url, title: title || parsed.hostname, description,
    image, favicon: null, siteName, type, domain: parsed.hostname,
    author, publishedDate, videoUrl: null, embedHtml: null,
    contentType: "text/html", fetchedAt: new Date().toISOString(),
  };
}

function extractFavicon(html: string, url: string): string | null {
  const match = html.match(/<link[^>]+rel="(?:shortcut )?icon"[^>]+href="([^"]+)"/i)
    || html.match(/<link[^>]+href="([^"]+)"[^>]+rel="(?:shortcut )?icon"/i);
  if (match?.[1]) {
    const href = match[1];
    return href.startsWith("http") ? href : new URL(href, url).href;
  }
  return null;
}

function decodeHtmlEntities(str: string): string {
  return str.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">")
    .replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&#x27;/g, "'");
}

function isPrivateIP(hostname: string): boolean {
  if (hostname === "localhost" || hostname === "127.0.0.1") return true;
  if (hostname.startsWith("10.") || hostname.startsWith("192.168.")) return true;
  if (/^172\.(1[6-9]|2\d|3[01])\./.test(hostname)) return true;
  return false;
}

// Batch preview (for message with multiple links)
export async function batchPreview(urls: string[]): Promise<Map<string, LinkPreview>> {
  const results = new Map<string, LinkPreview>();
  const unique = [...new Set(urls)].slice(0, 5); // max 5 previews

  await Promise.all(unique.map(async (url) => {
    try {
      const preview = await getPreview(url);
      results.set(url, preview);
    } catch {}
  }));

  return results;
}