Revalidate Tag — Tag-Based Revalidation for Grouped Content

// pages/products/[id].js — Tag-based ISR
export async function getStaticProps({ params }) {
    const res = await fetch(`https://api.example.com/products/${params.id}`);
    const product = await res.json();

    return {
        props: { product },
        revalidate: 60,
        // Tags that group related pages
        tags: [
            'products',
            `category:${product.category}`,
            `brand:${product.brand}`,
            product.featured ? 'featured' : null
        ].filter(Boolean)
    };
}

// pages/api/revalidate-by-tag.js — Revalidate by tag
export default async function handler(req, res) {
    const { secret, tag } = req.body;

    if (secret !== process.env.REVALIDATION_TOKEN) {
        return res.status(401).json({ message: 'Invalid token' });
    }

    try {
        // Revalidate all pages with the specified tag
        await res.revalidate({
            type: 'tag',
            tag
        });

        console.log(`Revalidated all pages tagged: ${tag}`);
        res.json({ revalidated: true, tag });
    } catch (err) {
        console.error(`Tag revalidation failed: ${tag}`, err);
        res.status(500).json({ error: err.message });
    }
}

// tag-hierarchy.js — Structured tag system
const tagHierarchy = {
    // Content type tags
    types: {
        post: 'type:post',
        product: 'type:product',
        page: 'type:page'
    },

    // Section tags
    sections: {
        blog: 'section:blog',
        shop: 'section:shop',
        docs: 'section:docs'
    },

    // Category tags
    categories: {
        electronics: 'category:electronics',
        clothing: 'category:clothing',
        food: 'category:food'
    },

    // Feature tags
    features: {
        featured: 'feature:featured',
        sale: 'feature:sale',
        new: 'feature:new'
    }
};

// Helper to generate tags for a product page
function getProductTags(product) {
    return [
        'type:product',
        'section:shop',
        `category:${product.category}`,
        `brand:${product.brand}`,
        product.isFeatured && 'feature:featured',
        product.isOnSale && 'feature:sale',
        product.isNew && 'feature:new'
    ].filter(Boolean);
}

// Helper to generate tags for a blog post
function getBlogTags(post) {
    return [
        'type:post',
        'section:blog',
        ...post.categories.map(c => `category:${c}`),
        ...post.tags.map(t => `tag:${t}`)
    ];
}

// pages/api/revalidate-multi.js — Revalidate multiple tags
export default async function handler(req, res) {
    const { secret, tags, source } = req.body;

    if (secret !== process.env.REVALIDATION_TOKEN) {
        return res.status(401).json({ message: 'Invalid token' });
    }

    const results = [];

    for (const tag of tags) {
        try {
            await res.revalidate({ type: 'tag', tag });
            results.push({ tag, status: 'success' });
            console.log(`Tag revalidated: ${tag}`);
        } catch (err) {
            results.push({ tag, status: 'failed', error: err.message });
            console.error(`Tag revalidation failed: ${tag}`, err);
        }
    }

    res.json({
        revalidated: true,
        source: source || 'unknown',
        results,
        time: Date.now()
    });
}

// Webhook handler for CMS
export async function cmsWebhookHandler(req, res) {
    const payload = req.body;

    // Determine which tags to revalidate based on the change
    const tagsToRevalidate = [];

    if (payload.contentType === 'product') {
        tagsToRevalidate.push(
            'type:product',
            `category:${payload.fields.category}`,
            'section:shop'
        );
        if (payload.fields.isFeatured) {
            tagsToRevalidate.push('feature:featured');
        }
    }

    if (payload.contentType === 'category') {
        // Category change affects all products in that category
        tagsToRevalidate.push(
            'type:product',
            `category:${payload.fields.slug}`,
            'section:shop'
        );
    }

    // Forward to revalidation endpoint
    const response = await fetch(
        `${process.env.NEXT_PUBLIC_BASE_URL}/api/revalidate-multi`,
        {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({
                secret: process.env.REVALIDATION_TOKEN,
                tags: tagsToRevalidate,
                source: 'cms-webhook'
            })
        }
    );

    const result = await response.json();
    res.json(result);
}

// lib/tag-registry.js — Track which pages have which tags
// This can be stored in Redis, a database, or a JSON file

class TagRegistry {
    constructor() {
        this.tagToPaths = new Map();
        this.pathToTags = new Map();
    }

    register(slug, tags) {
        // Store tags for this path
        this.pathToTags.set(slug, tags);

        // Store path for each tag
        for (const tag of tags) {
            if (!this.tagToPaths.has(tag)) {
                this.tagToPaths.set(tag, new Set());
            }
            this.tagToPaths.get(tag).add(slug);
        }
    }

    getPathsByTag(tag) {
        return this.tagToPaths.get(tag) || new Set();
    }

    getTagsByPath(slug) {
        return this.pathToTags.get(slug) || [];
    }

    getAllPaths() {
        const allPaths = new Set();
        for (const paths of this.tagToPaths.values()) {
            for (const path of paths) {
                allPaths.add(path);
            }
        }
        return allPaths;
    }

    remove(slug) {
        const tags = this.pathToTags.get(slug);
        if (tags) {
            for (const tag of tags) {
                this.tagToPaths.get(tag)?.delete(slug);
            }
            this.pathToTags.delete(slug);
        }
    }

    getStats() {
        const tagCounts = {};
        for (const [tag, paths] of this.tagToPaths.entries()) {
            tagCounts[tag] = paths.size;
        }
        return {
            totalTags: this.tagToPaths.size,
            totalPaths: this.pathToTags.size,
            tagCounts
        };
    }
}

export const registry = new TagRegistry();