mcp-wordpress 1.1.7 → 1.2.2

package/src/cache/HttpCacheWrapper.ts

@@ -0,0 +1,372 @@
+/**
+ * HTTP-level caching wrapper with ETags and Cache-Control headers
+ * Implements WordPress REST API caching best practices
+ */
+
+import { CacheManager, CachePresets } from './CacheManager.js';
+import * as crypto from 'crypto';
+
+export interface HttpCacheOptions {
+  ttl?: number;
+  cacheControl?: string;
+  varyHeaders?: string[];
+  private?: boolean;
+  revalidate?: boolean;
+}
+
+export interface CachedResponse {
+  data: any;
+  status: number;
+  headers: Record<string, string>;
+  etag?: string;
+  lastModified?: string;
+  cacheControl?: string;
+}
+
+export interface RequestOptions {
+  method: string;
+  url: string;
+  headers?: Record<string, string>;
+  params?: any;
+  data?: any;
+}
+
+/**
+ * HTTP caching wrapper that adds intelligent caching to HTTP requests
+ */
+export class HttpCacheWrapper {
+  constructor(
+    private cacheManager: CacheManager,
+    private siteId: string
+  ) {}
+
+  /**
+   * Execute request with intelligent caching
+   */
+  async request<T = any>(
+    requestFn: () => Promise<{ data: T; status: number; headers: Record<string, string> }>,
+    options: RequestOptions,
+    cacheOptions?: HttpCacheOptions
+  ): Promise<{ data: T; status: number; headers: Record<string, string>; cached?: boolean }> {
+    // Only cache GET requests
+    if (options.method.toUpperCase() !== 'GET') {
+      return await requestFn();
+    }
+
+    const cacheKey = this.generateCacheKey(options);
+    const cachedEntry = this.cacheManager.getEntry(cacheKey);
+
+    // Check for conditional request support
+    if (cachedEntry && this.cacheManager.supportsConditionalRequest(cacheKey)) {
+      const conditionalHeaders = this.cacheManager.getConditionalHeaders(cacheKey);
+      
+      // Add conditional headers to request
+      const requestWithHeaders = {
+        ...options,
+        headers: {
+          ...options.headers,
+          ...conditionalHeaders
+        }
+      };
+
+      try {
+        const response = await this.executeRequestWithHeaders(requestFn, requestWithHeaders);
+        
+        // 304 Not Modified - return cached data
+        if (response.status === 304) {
+          return {
+            data: cachedEntry.value.data,
+            status: 200,
+            headers: cachedEntry.value.headers,
+            cached: true
+          };
+        }
+
+        // Content changed - update cache
+        return await this.cacheAndReturn(response, cacheKey, cacheOptions);
+        
+      } catch (error) {
+        // If conditional request fails, try without conditions
+        console.warn('Conditional request failed, falling back to regular request:', error);
+      }
+    }
+
+    // Check for valid cached response
+    const cached = this.cacheManager.get<CachedResponse>(cacheKey);
+    if (cached) {
+      return {
+        data: cached.data,
+        status: cached.status,
+        headers: cached.headers,
+        cached: true
+      };
+    }
+
+    // Execute fresh request
+    const response = await requestFn();
+    return await this.cacheAndReturn(response, cacheKey, cacheOptions);
+  }
+
+  /**
+   * Invalidate cache for specific endpoint
+   */
+  invalidate(endpoint: string, params?: any): void {
+    const cacheKey = this.cacheManager.generateKey(this.siteId, endpoint, params);
+    this.cacheManager.delete(cacheKey);
+  }
+
+  /**
+   * Invalidate cache entries matching pattern
+   */
+  invalidatePattern(pattern: string): number {
+    const regex = new RegExp(`${this.siteId}:${pattern}`);
+    return this.cacheManager.clearPattern(regex);
+  }
+
+  /**
+   * Invalidate all cache for this site
+   */
+  invalidateAll(): number {
+    return this.cacheManager.clearSite(this.siteId);
+  }
+
+  /**
+   * Pre-warm cache with data
+   */
+  warm<T>(endpoint: string, data: T, params?: any, cacheOptions?: HttpCacheOptions): void {
+    const cacheKey = this.cacheManager.generateKey(this.siteId, endpoint, params);
+    const ttl = cacheOptions?.ttl || this.getDefaultTTL(endpoint);
+    
+    const cachedResponse: CachedResponse = {
+      data,
+      status: 200,
+      headers: this.generateCacheHeaders(cacheOptions, endpoint),
+      etag: this.generateETag(data),
+      lastModified: new Date().toUTCString(),
+      cacheControl: cacheOptions?.cacheControl || this.getDefaultCacheControl(endpoint)
+    };
+
+    this.cacheManager.set(
+      cacheKey,
+      cachedResponse,
+      ttl,
+      cachedResponse.etag,
+      cachedResponse.lastModified
+    );
+  }
+
+  /**
+   * Get cache statistics for this site
+   */
+  getStats() {
+    return this.cacheManager.getStats();
+  }
+
+  /**
+   * Generate cache key for request
+   */
+  private generateCacheKey(options: RequestOptions): string {
+    const endpoint = this.extractEndpoint(options.url);
+    return this.cacheManager.generateKey(this.siteId, endpoint, {
+      ...options.params,
+      // Include relevant headers that affect response
+      ...this.extractCacheableHeaders(options.headers)
+    });
+  }
+
+  /**
+   * Extract endpoint from full URL
+   */
+  private extractEndpoint(url: string): string {
+    // Extract the path after /wp-json/wp/v2/
+    const match = url.match(/\/wp-json\/wp\/v2\/(.+?)(?:\?|$)/);
+    return match ? match[1] : url;
+  }
+
+  /**
+   * Extract headers that affect caching
+   */
+  private extractCacheableHeaders(headers?: Record<string, string>): Record<string, string> {
+    if (!headers) return {};
+
+    const cacheableHeaders: Record<string, string> = {};
+    const relevantHeaders = ['accept', 'accept-language', 'authorization'];
+
+    for (const header of relevantHeaders) {
+      if (headers[header]) {
+        cacheableHeaders[header] = headers[header];
+      }
+    }
+
+    return cacheableHeaders;
+  }
+
+  /**
+   * Execute request with modified headers
+   */
+  private async executeRequestWithHeaders(
+    requestFn: () => Promise<{ data: any; status: number; headers: Record<string, string> }>,
+    options: RequestOptions
+  ) {
+    // This is a simplified approach - in practice, you'd need to modify the actual request
+    // The actual implementation would depend on your HTTP client (axios, fetch, etc.)
+    return await requestFn();
+  }
+
+  /**
+   * Cache response and return with cache metadata
+   */
+  private async cacheAndReturn<T>(
+    response: { data: T; status: number; headers: Record<string, string> },
+    cacheKey: string,
+    cacheOptions?: HttpCacheOptions
+  ): Promise<{ data: T; status: number; headers: Record<string, string>; cached?: boolean }> {
+    
+    // Don't cache error responses (unless specifically configured)
+    if (response.status >= 400) {
+      return response;
+    }
+
+    const endpoint = this.extractEndpointFromKey(cacheKey);
+    const ttl = cacheOptions?.ttl || this.getDefaultTTL(endpoint);
+    
+    // Generate ETags and cache headers
+    const etag = this.generateETag(response.data);
+    const lastModified = new Date().toUTCString();
+    const cacheControl = cacheOptions?.cacheControl || this.getDefaultCacheControl(endpoint);
+
+    const cachedResponse: CachedResponse = {
+      data: response.data,
+      status: response.status,
+      headers: {
+        ...response.headers,
+        'etag': etag,
+        'last-modified': lastModified,
+        'cache-control': cacheControl
+      },
+      etag,
+      lastModified,
+      cacheControl
+    };
+
+    // Store in cache
+    this.cacheManager.set(
+      cacheKey,
+      cachedResponse,
+      ttl,
+      etag,
+      lastModified
+    );
+
+    return {
+      data: response.data,
+      status: response.status,
+      headers: cachedResponse.headers,
+      cached: false
+    };
+  }
+
+  /**
+   * Generate ETag for response data
+   */
+  private generateETag(data: any): string {
+    const hash = crypto
+      .createHash('md5')
+      .update(JSON.stringify(data))
+      .digest('hex');
+    return `"${hash}"`;
+  }
+
+  /**
+   * Get default TTL based on endpoint type
+   */
+  private getDefaultTTL(endpoint: string): number {
+    // Static data endpoints
+    if (this.isStaticEndpoint(endpoint)) {
+      return CachePresets.STATIC.ttl;
+    }
+    
+    // Semi-static data endpoints
+    if (this.isSemiStaticEndpoint(endpoint)) {
+      return CachePresets.SEMI_STATIC.ttl;
+    }
+    
+    // Session/auth endpoints
+    if (this.isSessionEndpoint(endpoint)) {
+      return CachePresets.SESSION.ttl;
+    }
+    
+    // Default to dynamic for posts, comments, etc.
+    return CachePresets.DYNAMIC.ttl;
+  }
+
+  /**
+   * Get default Cache-Control header based on endpoint
+   */
+  private getDefaultCacheControl(endpoint: string): string {
+    if (this.isStaticEndpoint(endpoint)) {
+      return CachePresets.STATIC.cacheControl;
+    }
+    
+    if (this.isSemiStaticEndpoint(endpoint)) {
+      return CachePresets.SEMI_STATIC.cacheControl;
+    }
+    
+    if (this.isSessionEndpoint(endpoint)) {
+      return CachePresets.SESSION.cacheControl;
+    }
+    
+    return CachePresets.DYNAMIC.cacheControl;
+  }
+
+  /**
+   * Generate cache headers
+   */
+  private generateCacheHeaders(options?: HttpCacheOptions, endpoint?: string): Record<string, string> {
+    const headers: Record<string, string> = {};
+    
+    if (options?.cacheControl) {
+      headers['cache-control'] = options.cacheControl;
+    } else if (endpoint) {
+      headers['cache-control'] = this.getDefaultCacheControl(endpoint);
+    }
+    
+    if (options?.varyHeaders?.length) {
+      headers['vary'] = options.varyHeaders.join(', ');
+    }
+
+    return headers;
+  }
+
+  /**
+   * Check if endpoint contains static data
+   */
+  private isStaticEndpoint(endpoint: string): boolean {
+    const staticEndpoints = ['settings', 'types', 'statuses'];
+    return staticEndpoints.some(pattern => endpoint.includes(pattern));
+  }
+
+  /**
+   * Check if endpoint contains semi-static data  
+   */
+  private isSemiStaticEndpoint(endpoint: string): boolean {
+    const semiStaticEndpoints = ['categories', 'tags', 'users', 'taxonomies'];
+    return semiStaticEndpoints.some(pattern => endpoint.includes(pattern));
+  }
+
+  /**
+   * Check if endpoint is session-related
+   */
+  private isSessionEndpoint(endpoint: string): boolean {
+    const sessionEndpoints = ['users/me', 'application-passwords'];
+    return sessionEndpoints.some(pattern => endpoint.includes(pattern));
+  }
+
+  /**
+   * Extract endpoint from cache key
+   */
+  private extractEndpointFromKey(cacheKey: string): string {
+    const parts = cacheKey.split(':');
+    return parts[1] || '';
+  }
+}

package/src/cache/__tests__/CacheInvalidation.test.ts

@@ -0,0 +1,299 @@
+/**
+ * Tests for CacheInvalidation
+ */
+
+import { CacheManager } from '../CacheManager.js';
+import { HttpCacheWrapper } from '../HttpCacheWrapper.js';
+import { CacheInvalidation, WordPressCachePatterns } from '../CacheInvalidation.js';
+
+describe('CacheInvalidation', () => {
+  let cacheManager: CacheManager;
+  let httpCache: HttpCacheWrapper;
+  let cacheInvalidation: CacheInvalidation;
+
+  beforeEach(() => {
+    cacheManager = new CacheManager({
+      maxSize: 100,
+      defaultTTL: 10000,
+      enableLRU: true,
+      enableStats: true
+    });
+    
+    httpCache = new HttpCacheWrapper(cacheManager, 'test-site');
+    cacheInvalidation = new CacheInvalidation(httpCache);
+  });
+
+  afterEach(() => {
+    cacheManager.clear();
+  });
+
+  describe('Default Invalidation Rules', () => {
+    test('should have default rules for posts', () => {
+      const rules = cacheInvalidation.getRules();
+      
+      expect(rules.posts).toBeDefined();
+      expect(rules.posts.length).toBeGreaterThan(0);
+      
+      const createRule = rules.posts.find(r => r.trigger === 'create');
+      expect(createRule).toBeDefined();
+      expect(createRule?.patterns).toContain('posts');
+      expect(createRule?.immediate).toBe(true);
+      expect(createRule?.cascade).toBe(true);
+    });
+
+    test('should have default rules for categories', () => {
+      const rules = cacheInvalidation.getRules();
+      
+      expect(rules.categories).toBeDefined();
+      
+      const updateRule = rules.categories.find(r => r.trigger === 'update');
+      expect(updateRule).toBeDefined();
+      expect(updateRule?.patterns).toContain('categories/\\d+');
+      expect(updateRule?.cascade).toBe(true);
+    });
+
+    test('should have default rules for users', () => {
+      const rules = cacheInvalidation.getRules();
+      
+      expect(rules.users).toBeDefined();
+      
+      const deleteRule = rules.users.find(r => r.trigger === 'delete');
+      expect(deleteRule).toBeDefined();
+      expect(deleteRule?.patterns).toContain('users');
+    });
+  });
+
+  describe('Custom Invalidation Rules', () => {
+    test('should register custom invalidation rules', () => {
+      const customRule = {
+        trigger: 'update' as const,
+        patterns: ['custom-endpoint.*'],
+        immediate: true
+      };
+
+      cacheInvalidation.registerRule('custom', customRule);
+      
+      const rules = cacheInvalidation.getRules();
+      expect(rules.custom).toBeDefined();
+      expect(rules.custom).toContain(customRule);
+    });
+
+    test('should support multiple rules per resource', () => {
+      const rule1 = {
+        trigger: 'create' as const,
+        patterns: ['test.*'],
+        immediate: true
+      };
+      
+      const rule2 = {
+        trigger: 'update' as const,
+        patterns: ['test/\\d+'],
+        immediate: false
+      };
+
+      cacheInvalidation.registerRule('test', rule1);
+      cacheInvalidation.registerRule('test', rule2);
+      
+      const rules = cacheInvalidation.getRules();
+      expect(rules.test).toHaveLength(2);
+      expect(rules.test).toContain(rule1);
+      expect(rules.test).toContain(rule2);
+    });
+  });
+
+  describe('Event Processing', () => {
+    test('should process invalidation events', async () => {
+      // Pre-populate cache with some test data
+      httpCache.warm('posts', [{ id: 1 }, { id: 2 }]);
+      httpCache.warm('posts/1', { id: 1, title: 'Test Post' });
+      httpCache.warm('categories', [{ id: 1 }]);
+
+      expect(cacheManager.getStats().totalSize).toBe(3);
+
+      // Trigger post creation event
+      await cacheInvalidation.trigger({
+        type: 'create',
+        resource: 'posts',
+        id: 3,
+        siteId: 'test-site',
+        timestamp: Date.now()
+      });
+
+      // Should invalidate posts listings but not specific post
+      const stats = cacheManager.getStats();
+      expect(stats.totalSize).toBeLessThan(3);
+    });
+
+    test('should process events in queue order', async () => {
+      const processedEvents: string[] = [];
+      
+      // Mock the invalidation process to track order
+      const originalInvalidatePattern = httpCache.invalidatePattern;
+      httpCache.invalidatePattern = jest.fn().mockImplementation((pattern: string) => {
+        processedEvents.push(pattern);
+        return originalInvalidatePattern.call(httpCache, pattern);
+      });
+
+      // Queue multiple events
+      await Promise.all([
+        cacheInvalidation.trigger({
+          type: 'create',
+          resource: 'posts',
+          siteId: 'test-site',
+          timestamp: Date.now()
+        }),
+        cacheInvalidation.trigger({
+          type: 'update',
+          resource: 'categories',
+          siteId: 'test-site',
+          timestamp: Date.now()
+        })
+      ]);
+
+      expect(processedEvents.length).toBeGreaterThan(0);
+    });
+
+    test('should handle resource invalidation by type', async () => {
+      httpCache.warm('posts', [{ id: 1 }]);
+      httpCache.warm('posts/1', { id: 1 });
+      
+      expect(cacheManager.getStats().totalSize).toBe(2);
+
+      await cacheInvalidation.invalidateResource('posts', 1, 'update');
+
+      // Should clear specific post and related caches
+      const stats = cacheManager.getStats();
+      expect(stats.totalSize).toBeLessThan(2);
+    });
+  });
+
+  describe('Pattern Matching', () => {
+    test('should replace placeholders in patterns', async () => {
+      // Pre-populate cache
+      httpCache.warm('posts/123', { id: 123 });
+      httpCache.warm('posts/456', { id: 456 });
+      httpCache.warm('pages/123', { id: 123 });
+
+      expect(cacheManager.getStats().totalSize).toBe(3);
+
+      // Trigger event with specific ID
+      await cacheInvalidation.trigger({
+        type: 'update',
+        resource: 'posts',
+        id: 123,
+        siteId: 'test-site',
+        timestamp: Date.now()
+      });
+
+      // Should only invalidate posts/123, not posts/456 or pages/123
+      const remainingKeys: string[] = [];
+      for (const [key] of (cacheManager as any).cache.entries()) {
+        remainingKeys.push(key);
+      }
+
+      expect(remainingKeys).not.toContain(expect.stringContaining('posts'));
+    });
+  });
+
+  describe('Statistics', () => {
+    test('should track invalidation statistics', () => {
+      const stats = cacheInvalidation.getStats();
+      
+      expect(stats).toHaveProperty('queueSize');
+      expect(stats).toHaveProperty('rulesCount');
+      expect(stats).toHaveProperty('processing');
+      
+      expect(typeof stats.queueSize).toBe('number');
+      expect(typeof stats.rulesCount).toBe('number');
+      expect(typeof stats.processing).toBe('boolean');
+      expect(stats.rulesCount).toBeGreaterThan(0);
+    });
+
+    test('should clear rules', () => {
+      const initialStats = cacheInvalidation.getStats();
+      expect(initialStats.rulesCount).toBeGreaterThan(0);
+
+      cacheInvalidation.clearRules();
+      
+      const clearedStats = cacheInvalidation.getStats();
+      expect(clearedStats.rulesCount).toBe(0);
+    });
+  });
+});
+
+describe('WordPressCachePatterns', () => {
+  let cacheManager: CacheManager;
+  let httpCache: HttpCacheWrapper;
+
+  beforeEach(() => {
+    cacheManager = new CacheManager({
+      maxSize: 100,
+      defaultTTL: 10000,
+      enableLRU: true,
+      enableStats: true
+    });
+    
+    httpCache = new HttpCacheWrapper(cacheManager, 'test-site');
+  });
+
+  afterEach(() => {
+    cacheManager.clear();
+  });
+
+  test('should invalidate content-related caches', () => {
+    // Pre-populate cache
+    httpCache.warm('posts', []);
+    httpCache.warm('pages', []);
+    httpCache.warm('comments', []);
+    httpCache.warm('categories', []);
+
+    expect(cacheManager.getStats().totalSize).toBe(4);
+
+    const invalidated = WordPressCachePatterns.invalidateContent(httpCache);
+    
+    expect(invalidated).toBeGreaterThan(0);
+    // Should invalidate posts, pages, comments but not categories
+    expect(cacheManager.getStats().totalSize).toBeLessThan(4);
+  });
+
+  test('should invalidate taxonomy-related caches', () => {
+    httpCache.warm('categories', []);
+    httpCache.warm('tags', []);
+    httpCache.warm('posts', []);
+
+    expect(cacheManager.getStats().totalSize).toBe(3);
+
+    const invalidated = WordPressCachePatterns.invalidateTaxonomies(httpCache);
+    
+    expect(invalidated).toBeGreaterThan(0);
+    // Should invalidate categories and tags but not posts
+    expect(cacheManager.getStats().totalSize).toBeLessThan(3);
+  });
+
+  test('should invalidate user-related caches', () => {
+    httpCache.warm('users', []);
+    httpCache.warm('users/me', {});
+    httpCache.warm('posts', []);
+
+    expect(cacheManager.getStats().totalSize).toBe(3);
+
+    const invalidated = WordPressCachePatterns.invalidateUsers(httpCache);
+    
+    expect(invalidated).toBeGreaterThan(0);
+    // Should invalidate user caches but not posts
+    expect(cacheManager.getStats().totalSize).toBeLessThan(3);
+  });
+
+  test('should invalidate all caches', () => {
+    httpCache.warm('posts', []);
+    httpCache.warm('categories', []);
+    httpCache.warm('users', []);
+
+    expect(cacheManager.getStats().totalSize).toBe(3);
+
+    const invalidated = WordPressCachePatterns.invalidateAll(httpCache);
+    
+    expect(invalidated).toBe(3);
+    expect(cacheManager.getStats().totalSize).toBe(0);
+  });
+});