1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

TAGGING PHASE (Cache Ingestion)
═══════════════════════════════════════════════════════════════════
 
Request: GET /articles/123
Response Headers:
  Surrogate-Key: article-123 author-456 category-tech featured
  Cache-Control: max-age=3600
 
CDN Operations:
  1. Cache response content with cache key "/articles/123"
  2. Associate tags with cache key:
     ┌─────────────────┬────────────────────────────────┐
     │ Tag             │ Associated Cache Keys          │
     ├─────────────────┼────────────────────────────────┤
     │ article-123     │ /articles/123                  │
     │ author-456      │ /articles/123, /authors/456    │
     │ category-tech   │ /articles/123, /articles/789...│
     │ featured        │ /articles/123, /homepage       │
     └─────────────────┴────────────────────────────────┘
 
PURGE PHASE (Content Update)
═══════════════════════════════════════════════════════════════════
 
Event: Author 456 updates their bio
Action: Purge by tag "author-456"
 
CDN Operations:
  1. Look up tag "author-456" in tag index
  2. Find all associated cache keys:
     - /articles/123
     - /articles/567
     - /articles/890
     - /authors/456
     - /api/authors/456
  3. Invalidate ALL matching cache entries
  4. No URL enumeration required!
 
Result: All content affected by author change is invalidated,
        regardless of URL structure or count.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

/**
 * E-commerce Tag Taxonomy Design
 * 
 * This taxonomy supports granular invalidation for a complex
 * e-commerce platform with products, categories, brands, pricing,
 * inventory, and user-generated content.
 */
 
interface TagTaxonomy {
  // Primary entity tags - invalidate specific entities
  primary: {
    product: string;      // product:{id} - Product detail pages, API
    category: string;     // category:{slug} - Category pages, navigation
    brand: string;        // brand:{slug} - Brand pages, filtering
    user: string;         // user:{id} - User profiles, reviews
    order: string;        // order:{id} - Order status pages
  };
  
  // Relationship tags - invalidate related content
  relationship: {
    categoryProducts: string;  // category:{slug}:products - Products in category
    brandProducts: string;     // brand:{slug}:products - Products by brand
    userReviews: string;       // user:{id}:reviews - Reviews by user
    productReviews: string;    // product:{id}:reviews - Reviews of product
  };
  
  // Type tags - invalidate by content type
  type: {
    pdp: string;          // type:pdp - All product detail pages
    plp: string;          // type:plp - All product listing pages
    search: string;       // type:search - All search results
    api: string;          // type:api - All API responses
    static: string;       // type:static - Static assets
  };
  
  // Global concern tags - cross-cutting invalidation
  global: {
    pricing: string;      // global:pricing - Any price-dependent content
    inventory: string;    // global:inventory - Any stock-dependent content
    promotions: string;   // global:promotions - Promotional content
    navigation: string;   // global:navigation - Navigation elements
  };
}
 
// Example: Product detail page tag generation
function generateProductPageTags(product: Product): string[] {
  const tags: string[] = [
    // Primary entity
    `product:${product.id}`,
    
    // Category relationships (product may be in multiple categories)
    ...product.categories.map(cat => `category:${cat.slug}:products`),
    
    // Brand relationship
    `brand:${product.brand.slug}:products`,
    
    // Content type
    'type:pdp',
    
    // Global concerns (if applicable)
    'global:pricing',      // All PDPs show pricing
    'global:inventory',    // All PDPs show stock status
    
    // Promotional tags (if product is featured)
    ...(product.isPromoted ? ['global:promotions'] : []),
    
    // Variant tags (for products with variants)
    ...product.variants.map(v => `variant:${v.sku}`),
  ];
  
  return tags;
}
 
// Example: Category listing page tag generation
function generateCategoryPageTags(category: Category): string[] {
  return [
    // Primary entity
    `category:${category.slug}`,
    
    // Content type
    'type:plp',
    
    // Navigation (category pages are in navigation)
    'global:navigation',
    
    // Global concerns
    'global:pricing',
    'global:inventory',
    
    // Parent category (for hierarchical invalidation)
    ...(category.parent ? [`category:${category.parent.slug}:children`] : []),
  ];
}
 
// Invalidation examples
async function handleProductUpdate(productId: string): Promise<void> {
  // Invalidate product-specific content
  await cdn.purgeByTag(`product:${productId}`);
}
 
async function handleCategoryUpdate(categorySlug: string): Promise<void> {
  // Invalidate category page AND all products in category
  await cdn.purgeByTag([
    `category:${categorySlug}`,
    `category:${categorySlug}:products`
  ]);
}
 
async function handlePriceChange(): Promise<void> {
  // Global price change: invalidate all price-dependent content
  await cdn.purgeByTag('global:pricing');
  // This invalidates ALL PDPs, PLPs, cart pages, etc.
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

// Origin server: Adding Surrogate-Key header
// Express.js middleware example
 
import { Request, Response, NextFunction } from 'express';
 
interface TaggableResponse extends Response {
  addSurrogateKeys: (keys: string[]) => void;
  getSurrogateKeys: () => string[];
}
 
function surrogateKeyMiddleware(
  req: Request, 
  res: TaggableResponse, 
  next: NextFunction
) {
  const surrogateKeys: Set<string> = new Set();
  
  res.addSurrogateKeys = (keys: string[]) => {
    keys.forEach(key => surrogateKeys.add(key));
  };
  
  res.getSurrogateKeys = () => Array.from(surrogateKeys);
  
  // Set header before response is sent
  res.on('finish', () => {
    // Header was set on explicit response
  });
  
  // Intercept response send to add header
  const originalSend = res.send.bind(res);
  res.send = function(body: any) {
    if (surrogateKeys.size > 0) {
      res.setHeader('Surrogate-Key', Array.from(surrogateKeys).join(' '));
    }
    return originalSend(body);
  };
  
  next();
}
 
// Usage in route handler
app.get('/products/:id', async (req, res: TaggableResponse) => {
  const product = await getProduct(req.params.id);
  
  // Add surrogate keys for this response
  res.addSurrogateKeys([
    `product:${product.id}`,
    `brand:${product.brand.slug}:products`,
    ...product.categories.map(c => `category:${c.slug}:products`),
    'type:pdp',
    'global:pricing'
  ]);
  
  res.json(product);
});
 
// Fastly purge by tag
const fastlyClient = new FastlyClient({
  apiKey: process.env.FASTLY_API_KEY,
  serviceId: process.env.FASTLY_SERVICE_ID
});
 
async function purgeByTag(tag: string): Promise<void> {
  await fastlyClient.purgeByKey(tag); // Soft purge by default
  console.log(`Purged tag: ${tag}`);
}
 
async function hardPurgeByTag(tag: string): Promise<void> {
  await fastlyClient.purgeByKey(tag, { soft: false });
  console.log(`Hard purged tag: ${tag}`);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

// Cloudflare Workers: Adding Cache-Tag header
 
export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    const url = new URL(request.url);
    
    // Fetch from origin
    const response = await fetch(request);
    
    // Clone response to modify headers
    const newResponse = new Response(response.body, response);
    
    // Generate tags based on URL pattern
    const tags = generateTagsForRequest(url);
    
    // Cloudflare: comma-separated tags in Cache-Tag header
    if (tags.length > 0) {
      newResponse.headers.set('Cache-Tag', tags.join(','));
    }
    
    return newResponse;
  }
};
 
function generateTagsForRequest(url: URL): string[] {
  const tags: string[] = [];
  const path = url.pathname;
  
  // Product pages: /products/123
  const productMatch = path.match(/^\/products\/(\d+)/);
  if (productMatch) {
    tags.push(`product-${productMatch[1]}`, 'type-pdp');
  }
  
  // Category pages: /categories/electronics
  const categoryMatch = path.match(/^\/categories\/([^/]+)/);
  if (categoryMatch) {
    tags.push(`category-${categoryMatch[1]}`, 'type-plp');
  }
  
  // API endpoints
  if (path.startsWith('/api/')) {
    tags.push('type-api');
  }
  
  return tags;
}
 
// Cloudflare purge by tags (API call)
async function purgeCloudflareByTags(tags: string[]): Promise<void> {
  // Note: Cloudflare limits to 30 tags per request
  const TAGS_PER_REQUEST = 30;
  
  for (let i = 0; i < tags.length; i += TAGS_PER_REQUEST) {
    const batch = tags.slice(i, i + TAGS_PER_REQUEST);
    
    await fetch(
      `https://api.cloudflare.com/client/v4/zones/${ZONE_ID}/purge_cache`,
      {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${API_TOKEN}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({ tags: batch })
      }
    );
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

# Django: Automatic model-based cache tagging
 
from django.db import models
from django.core.cache import cache
from functools import wraps
 
class CacheTagMixin:
    """
    Mixin for Django models that provides automatic cache tag generation.
    """
    
    @classmethod
    def get_cache_tag(cls, pk=None):
        """Generate cache tag for this model/instance."""
        model_name = cls._meta.model_name
        if pk:
            return f"{model_name}:{pk}"
        return f"type:{model_name}"
    
    def get_instance_tags(self):
        """Get all cache tags for this instance."""
        tags = [
            self.get_cache_tag(self.pk),  # Instance tag
            f"type:{self._meta.model_name}",  # Type tag
        ]
        
        # Add relationship tags
        for field in self._meta.get_fields():
            if field.is_relation and hasattr(self, field.name):
                related = getattr(self, field.name)
                if related and hasattr(related, 'get_cache_tag'):
                    tags.append(f"{related.get_cache_tag()}:{self._meta.model_name}s")
        
        return tags
 
class Product(CacheTagMixin, models.Model):
    name = models.CharField(max_length=255)
    brand = models.ForeignKey('Brand', on_delete=models.CASCADE)
    categories = models.ManyToManyField('Category')
    price = models.DecimalField(max_digits=10, decimal_places=2)
    
    def get_instance_tags(self):
        tags = super().get_instance_tags()
        
        # Add category relationship tags
        for category in self.categories.all():
            tags.append(f"category:{category.slug}:products")
        
        # Add brand relationship tag
        tags.append(f"brand:{self.brand.slug}:products")
        
        # Add pricing concern tag
        tags.append("global:pricing")
        
        return tags
 
# View decorator for automatic tagging
def cache_tagged(view_func):
    @wraps(view_func)
    def wrapper(request, *args, **kwargs):
        response = view_func(request, *args, **kwargs)
        
        # Collect tags from context
        if hasattr(request, '_cache_tags'):
            tags = request._cache_tags
            response['Surrogate-Key'] = ' '.join(tags)
        
        return response
    return wrapper
 
# Usage in view
@cache_tagged
def product_detail(request, product_id):
    product = Product.objects.get(id=product_id)
    
    # Register tags for this response
    request._cache_tags = product.get_instance_tags()
    
    return render(request, 'products/detail.html', {'product': product})
 
# Model signal for automatic invalidation on save
from django.db.models.signals import post_save, post_delete
from django.dispatch import receiver
 
@receiver(post_save, sender=Product)
def invalidate_product_cache(sender, instance, **kwargs):
    """Automatically invalidate cache when product is saved."""
    cdn_client.purge_by_tags(instance.get_instance_tags())
 
@receiver(post_delete, sender=Product)
def invalidate_deleted_product_cache(sender, instance, **kwargs):
    """Invalidate cache when product is deleted."""
    cdn_client.purge_by_tags(instance.get_instance_tags())

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174

/**
 * Content Relationship Graph for Tag Resolution
 * 
 * This system models content dependencies to compute
 * all affected tags when an entity changes.
 */
 
interface EntityRelationship {
  entity: string;           // e.g., "author"
  relatedEntity: string;    // e.g., "article"  
  tagPattern: string;       // e.g., "{entity}:{id}:{relatedEntity}s"
  propagation: 'direct' | 'aggregate' | 'derived';
}
 
const RELATIONSHIP_GRAPH: EntityRelationship[] = [
  // Author → Articles: author update invalidates author's articles
  {
    entity: 'author',
    relatedEntity: 'article',
    tagPattern: '{entity}:{id}:{relatedEntity}s',
    propagation: 'direct'
  },
  
  // Category ↔ Products: bidirectional relationship
  {
    entity: 'product',
    relatedEntity: 'category',
    tagPattern: 'category:{relatedId}:products',
    propagation: 'direct'
  },
  {
    entity: 'category',
    relatedEntity: 'product',
    tagPattern: 'category:{id}:products',
    propagation: 'direct'
  },
  
  // Product → Reviews: product change affects review aggregates
  {
    entity: 'product',
    relatedEntity: 'review',
    tagPattern: 'product:{id}:reviews',
    propagation: 'derived'
  },
  
  // Order → Reports: order changes affect aggregate reports
  {
    entity: 'order',
    relatedEntity: 'report',
    tagPattern: 'report:aggregate',
    propagation: 'aggregate'
  }
];
 
class TagResolver {
  private relationships: Map<string, EntityRelationship[]>;
  
  constructor(relationships: EntityRelationship[]) {
    this.relationships = new Map();
    
    for (const rel of relationships) {
      if (!this.relationships.has(rel.entity)) {
        this.relationships.set(rel.entity, []);
      }
      this.relationships.get(rel.entity)!.push(rel);
    }
  }
  
  /**
   * Resolve all tags that should be invalidated when an entity changes.
   */
  async resolveInvalidationTags(
    entityType: string,
    entityId: string,
    entityData?: Record<string, any>
  ): Promise<string[]> {
    const tags = new Set<string>();
    
    // Primary entity tag
    tags.add(`${entityType}:${entityId}`);
    
    // Type tag
    tags.add(`type:${entityType}`);
    
    // Resolve relationship tags
    const relationships = this.relationships.get(entityType) || [];
    
    for (const rel of relationships) {
      const resolvedTag = await this.resolveRelationshipTag(
        rel, 
        entityId, 
        entityData
      );
      
      if (resolvedTag) {
        if (Array.isArray(resolvedTag)) {
          resolvedTag.forEach(t => tags.add(t));
        } else {
          tags.add(resolvedTag);
        }
      }
    }
    
    return Array.from(tags);
  }
  
  private async resolveRelationshipTag(
    rel: EntityRelationship,
    entityId: string,
    entityData?: Record<string, any>
  ): Promise<string | string[] | null> {
    
    let tag = rel.tagPattern;
    
    // Replace {entity} placeholder
    tag = tag.replace('{entity}', rel.entity);
    
    // Replace {id} placeholder
    tag = tag.replace('{id}', entityId);
    
    // Replace {relatedId} if needed (requires looking up relationship)
    if (tag.includes('{relatedId}') && entityData) {
      const relatedIds = await this.lookupRelatedIds(
        rel.entity,
        entityId,
        rel.relatedEntity
      );
      
      return relatedIds.map(relId => 
        tag.replace('{relatedId}', relId)
      );
    }
    
    return tag;
  }
  
  private async lookupRelatedIds(
    entity: string,
    entityId: string,
    relatedEntity: string
  ): Promise<string[]> {
    // In practice, query your database for related entity IDs
    // This is a simplified example
    return await database.query(`
      SELECT related_id FROM ${entity}_${relatedEntity}_relations
      WHERE entity_id = ?
    `, [entityId]);
  }
}
 
// Usage
const resolver = new TagResolver(RELATIONSHIP_GRAPH);
 
async function handleProductUpdate(productId: string): Promise<void> {
  // Fetch product data including relationships
  const product = await database.getProduct(productId);
  
  // Resolve all tags that need invalidation
  const tags = await resolver.resolveInvalidationTags(
    'product',
    productId,
    {
      categories: product.categories.map(c => c.id),
      brand: product.brand.id
    }
  );
  
  console.log('Invalidating tags:', tags);
  // Example output:
  // ['product:123', 'type:product', 'category:456:products', 
  //  'category:789:products', 'brand:acme:products', 'product:123:reviews']
  
  await cdn.purgeByTags(tags);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

// Monitor tag cardinality and usage patterns
 
class TagCardinityMonitor {
  private tagCreations: Map<string, number> = new Map();
  private tagPurges: Map<string, number> = new Map();
  
  recordTagCreation(tag: string): void {
    const count = this.tagCreations.get(tag) || 0;
    this.tagCreations.set(tag, count + 1);
    
    metrics.increment('cache.tag.created', { tag: this.normalizeTag(tag) });
  }
  
  recordTagPurge(tag: string): void {
    const count = this.tagPurges.get(tag) || 0;
    this.tagPurges.set(tag, count + 1);
    
    metrics.increment('cache.tag.purged', { tag: this.normalizeTag(tag) });
  }
  
  async analyzeCardinality(): Promise<CardinalityReport> {
    // Identify high-cardinality tag patterns
    const patterns: Map<string, number> = new Map();
    
    for (const tag of this.tagCreations.keys()) {
      const pattern = this.extractPattern(tag);
      const count = patterns.get(pattern) || 0;
      patterns.set(pattern, count + 1);
    }
    
    // Find unused tags (created but never purged)
    const unusedTags: string[] = [];
    for (const tag of this.tagCreations.keys()) {
      if (!this.tagPurges.has(tag)) {
        unusedTags.push(tag);
      }
    }
    
    return {
      totalUniqueTags: this.tagCreations.size,
      patternCardinality: Object.fromEntries(patterns),
      unusedTags: unusedTags.slice(0, 100),  // Sample
      recommendations: this.generateRecommendations(patterns)
    };
  }
  
  private normalizeTag(tag: string): string {
    // Replace IDs with placeholders for metric aggregation
    return tag.replace(/:\d+/g, ':*');
  }
  
  private extractPattern(tag: string): string {
    // Extract pattern: "product:123" → "product:*"
    return tag.replace(/:[^:]+$/g, ':*');
  }
  
  private generateRecommendations(
    patterns: Map<string, number>
  ): string[] {
    const recommendations: string[] = [];
    
    for (const [pattern, count] of patterns) {
      if (count > 100000) {
        recommendations.push(
          `High cardinality pattern "${pattern}" (${count} tags). ` +
                                `Consider batching or hierarchical grouping.`
        );
      }
    }
    
    return recommendations;
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

// Jest test suite for tag-based invalidation
 
describe('Tag-Based Invalidation', () => {
  describe('Tag Assignment', () => {
    it('should assign primary entity tag to product page', async () => {
      const response = await fetchWithCacheHeaders('/products/123');
      const tags = parseSurrogateKey(response.headers['surrogate-key']);
      
      expect(tags).toContain('product:123');
    });
    
    it('should assign category relationship tags', async () => {
      // Product 123 is in categories 'electronics' and 'accessories'
      const response = await fetchWithCacheHeaders('/products/123');
      const tags = parseSurrogateKey(response.headers['surrogate-key']);
      
      expect(tags).toContain('category:electronics:products');
      expect(tags).toContain('category:accessories:products');
    });
    
    it('should assign global concern tags', async () => {
      const response = await fetchWithCacheHeaders('/products/123');
      const tags = parseSurrogateKey(response.headers['surrogate-key']);
      
      expect(tags).toContain('global:pricing');
      expect(tags).toContain('type:pdp');
    });
    
    it('should not exceed tag count limits', async () => {
      // Product with many categories
      const response = await fetchWithCacheHeaders('/products/456');
      const tags = parseSurrogateKey(response.headers['surrogate-key']);
      
      expect(tags.length).toBeLessThanOrEqual(30); // Cloudflare limit
    });
  });
  
  describe('Tag Resolution', () => {
    it('should resolve product update to all affected tags', async () => {
      const tags = await resolver.resolveInvalidationTags('product', '123');
      
      expect(tags).toContain('product:123');
      expect(tags).toContain('category:electronics:products');
      expect(tags).toContain('brand:acme:products');
      expect(tags).toContain('product:123:reviews');
    });
    
    it('should resolve category update to category and product tags', async () => {
      const tags = await resolver.resolveInvalidationTags('category', 'electronics');
      
      expect(tags).toContain('category:electronics');
      expect(tags).toContain('category:electronics:products');
      expect(tags).toContain('global:navigation');
    });
    
    it('should handle entity with no relationships', async () => {
      const tags = await resolver.resolveInvalidationTags('standalone', '789');
      
      expect(tags).toContain('standalone:789');
      expect(tags).toContain('type:standalone');
      expect(tags.length).toBe(2);
    });
  });
  
  describe('Invalidation Propagation', () => {
    it('should invalidate all product pages when category changes', async () => {
      // Setup: Cache multiple product pages in category
      await warmCache(['/products/1', '/products/2', '/products/3']);
      
      // Act: Update category and trigger invalidation
      await updateCategory('electronics');
      await triggerInvalidation('category:electronics:products');
      await waitForPropagation();
      
      // Assert: All product pages should be fresh
      for (const path of ['/products/1', '/products/2', '/products/3']) {
        const response = await fetch(path);
        expect(response.headers['x-cache']).toBe('MISS');
      }
    });
    
    it('should not invalidate unrelated content', async () => {
      // Setup: Cache product and unrelated article
      await warmCache(['/products/123', '/articles/456']);
      
      // Act: Invalidate product
      await triggerInvalidation('product:123');
      await waitForPropagation();
      
      // Assert: Article should still be cached
      const articleResponse = await fetch('/articles/456');
      expect(articleResponse.headers['x-cache']).toBe('HIT');
    });
  });
  
  describe('Edge Cases', () => {
    it('should handle tag with special characters', async () => {
      // Tag with URL-unsafe characters
      const tags = await resolver.resolveInvalidationTags(
        'product', 
        'item-with-special-chars_123'
      );
      
      expect(tags).toContain('product:item-with-special-chars_123');
    });
    
    it('should handle circular relationships without infinite loop', async () => {
      // Product A references Product B, Product B references Product A
      const tags = await resolver.resolveInvalidationTags('product', 'A');
      
      // Should complete without hanging
      expect(tags).toBeDefined();
    });
    
    it('should handle deleted entity references gracefully', async () => {
      // Product references deleted category
      const tags = await resolver.resolveInvalidationTags('product', '789');
      
      // Should not throw, should skip dead references
      expect(tags).toContain('product:789');
    });
  });
});