All files / src/app/api/admin/cache/invalidate route.ts

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
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
/**
 * Cache Invalidation API
 *
 * POST /api/admin/cache/invalidate - Invalidate cache entries (Admin only)
 *
 * Invalidates both caching systems:
 * - Core cache (Redis/memory hybrid) - used by API routes
 * - Node-cache (legacy) - used by some cached queries
 */

import { NextRequest, NextResponse } from 'next/server';
import { withErrorHandling, withAdmin, ApiError } from '@/lib/api';
import {
  flushAllCaches,
  invalidateAllProductCaches,
  invalidateAllCategoryCaches,
  invalidateAllContentCaches,
  invalidateHeroCache,
  invalidateAllSupportCaches,
  invalidateAllPromotionCaches,
  invalidateAdminCaches,
  cacheService,
  CACHE_VERSION,
} from '@/lib/cache';
import { clearCache, invalidatePattern as invalidateCorePattern } from '@/lib/core';

type CacheTarget =
  | 'all'
  | 'products'
  | 'categories'
  | 'content'
  | 'hero'
  | 'support'
  | 'promotions'
  | 'admin'
  | 'pattern'
  | 'key';

interface InvalidateRequest {
  target: CacheTarget;
  pattern?: string; // For pattern-based invalidation
  key?: string; // For single key invalidation
}

async function handlePost(request: NextRequest): Promise<NextResponse> {
  const body = await request.json() as InvalidateRequest;
  const { target, pattern, key } = body;

  if (!target) {
    throw ApiError.validation('target is required');
  }

  let invalidatedCount = 0;
  let message = '';

  switch (target) {
    case 'all':
      // Flush both caching systems
      flushAllCaches();
      await clearCache();
      message = 'All caches flushed';
      break;

    case 'products':
      invalidateAllProductCaches();
      await invalidateCorePattern('products:*');
      message = 'Product caches invalidated';
      break;

    case 'categories':
      invalidateAllCategoryCaches();
      await invalidateCorePattern('categories:*');
      message = 'Category caches invalidated';
      break;

    case 'content':
      invalidateAllContentCaches();
      await invalidateCorePattern('content:*');
      message = 'Content caches invalidated';
      break;

    case 'hero':
      invalidateHeroCache();
      await invalidateCorePattern('content:hero:*');
      message = 'Hero section caches invalidated';
      break;

    case 'support':
      invalidateAllSupportCaches();
      await invalidateCorePattern('support:*');
      message = 'Support article caches invalidated';
      break;

    case 'promotions':
      invalidateAllPromotionCaches();
      await invalidateCorePattern('promotions:*');
      message = 'Promotion caches invalidated';
      break;

    case 'admin':
      invalidateAdminCaches();
      await invalidateCorePattern('admin:*');
      message = 'Admin caches invalidated';
      break;

    case 'pattern':
      if (!pattern) {
        throw ApiError.validation('pattern is required for pattern-based invalidation');
      }
      // Invalidate in both caches
      invalidatedCount = cacheService.deletePattern(pattern);
      await invalidateCorePattern(pattern);
      message = `Invalidated keys matching pattern "${pattern}"`;
      break;

    case 'key':
      if (!key) {
        throw ApiError.validation('key is required for single key invalidation');
      }
      invalidatedCount = cacheService.delete(key);
      await clearCache(key);
      message = invalidatedCount > 0 ? `Key "${key}" invalidated` : `Key "${key}" not found`;
      break;

    default:
      throw ApiError.validation(`Unknown target: ${target}`);
  }

  return NextResponse.json({
    success: true,
    data: {
      message,
      invalidatedCount,
      cacheVersion: CACHE_VERSION,
      timestamp: new Date().toISOString(),
    },
  });
}

export const POST = withErrorHandling(withAdmin(handlePost));