mcp-wordpress 1.2.2 → 1.3.0

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

@@ -2,10 +2,10 @@
  * Tests for HttpCacheWrapper
  */
 
-import { CacheManager } from '../CacheManager.js';
-import { HttpCacheWrapper } from '../HttpCacheWrapper.js';
+import { CacheManager } from "../CacheManager.js";
+import { HttpCacheWrapper } from "../HttpCacheWrapper.js";
 
-describe('HttpCacheWrapper', () => {
+describe("HttpCacheWrapper", () => {
   let cacheManager: CacheManager;
   let httpCache: HttpCacheWrapper;
   let mockRequestFn: jest.Mock;
@@ -15,11 +15,11 @@ describe('HttpCacheWrapper', () => {
       maxSize: 100,
       defaultTTL: 1000,
       enableLRU: true,
-      enableStats: true
+      enableStats: true,
     });
-    
-    httpCache = new HttpCacheWrapper(cacheManager, 'test-site');
-    
+
+    httpCache = new HttpCacheWrapper(cacheManager, "test-site");
+
     mockRequestFn = jest.fn();
   });
 
@@ -28,21 +28,21 @@ describe('HttpCacheWrapper', () => {
     jest.clearAllMocks();
   });
 
-  describe('Request Caching', () => {
-    test('should cache GET requests', async () => {
+  describe("Request Caching", () => {
+    test("should cache GET requests", async () => {
       const mockResponse = {
-        data: { id: 1, title: 'Test Post' },
+        data: { id: 1, title: "Test Post" },
         status: 200,
-        headers: {}
+        headers: {},
       };
-      
+
       mockRequestFn.mockResolvedValue(mockResponse);
-      
+
       const requestOptions = {
-        method: 'GET',
-        url: 'https://example.com/wp-json/wp/v2/posts',
+        method: "GET",
+        url: "https://example.com/wp-json/wp/v2/posts",
         headers: {},
-        params: {}
+        params: {},
       };
 
       // First request should hit the API
@@ -58,96 +58,96 @@ describe('HttpCacheWrapper', () => {
       expect(result2.cached).toBe(true);
     });
 
-    test('should not cache non-GET requests', async () => {
+    test("should not cache non-GET requests", async () => {
       const mockResponse = {
-        data: { id: 1, title: 'Test Post' },
+        data: { id: 1, title: "Test Post" },
         status: 201,
-        headers: {}
+        headers: {},
       };
-      
+
       mockRequestFn.mockResolvedValue(mockResponse);
-      
+
       const requestOptions = {
-        method: 'POST',
-        url: 'https://example.com/wp-json/wp/v2/posts',
+        method: "POST",
+        url: "https://example.com/wp-json/wp/v2/posts",
         headers: {},
         params: {},
-        data: { title: 'New Post' }
+        data: { title: "New Post" },
       };
 
       // Both requests should hit the API
       const result1 = await httpCache.request(mockRequestFn, requestOptions);
       const result2 = await httpCache.request(mockRequestFn, requestOptions);
-      
+
       expect(mockRequestFn).toHaveBeenCalledTimes(2);
       expect(result1.cached).toBeUndefined();
       expect(result2.cached).toBeUndefined();
     });
 
-    test('should not cache error responses', async () => {
+    test("should not cache error responses", async () => {
       const errorResponse = {
-        data: { error: 'Not found' },
+        data: { error: "Not found" },
         status: 404,
-        headers: {}
+        headers: {},
       };
-      
+
       mockRequestFn.mockResolvedValue(errorResponse);
-      
+
       const requestOptions = {
-        method: 'GET',
-        url: 'https://example.com/wp-json/wp/v2/posts/999',
+        method: "GET",
+        url: "https://example.com/wp-json/wp/v2/posts/999",
         headers: {},
-        params: {}
+        params: {},
       };
 
       // Both requests should hit the API (no caching of 404)
       await httpCache.request(mockRequestFn, requestOptions);
       await httpCache.request(mockRequestFn, requestOptions);
-      
+
       expect(mockRequestFn).toHaveBeenCalledTimes(2);
     });
 
-    test('should generate ETags for responses', async () => {
+    test("should generate ETags for responses", async () => {
       const mockResponse = {
-        data: { id: 1, title: 'Test Post' },
+        data: { id: 1, title: "Test Post" },
         status: 200,
-        headers: {}
+        headers: {},
       };
-      
+
       mockRequestFn.mockResolvedValue(mockResponse);
-      
+
       const requestOptions = {
-        method: 'GET',
-        url: 'https://example.com/wp-json/wp/v2/posts/1',
+        method: "GET",
+        url: "https://example.com/wp-json/wp/v2/posts/1",
         headers: {},
-        params: {}
+        params: {},
       };
 
       const result = await httpCache.request(mockRequestFn, requestOptions);
-      
+
       expect(result.headers.etag).toBeDefined();
       expect(result.headers.etag).toMatch(/^"[a-f0-9]{32}"$/);
-      expect(result.headers['last-modified']).toBeDefined();
-      expect(result.headers['cache-control']).toBeDefined();
+      expect(result.headers["last-modified"]).toBeDefined();
+      expect(result.headers["cache-control"]).toBeDefined();
     });
   });
 
-  describe('Cache Invalidation', () => {
-    test('should invalidate specific endpoint', async () => {
+  describe("Cache Invalidation", () => {
+    test("should invalidate specific endpoint", async () => {
       // Cache a response
       const mockResponse = {
-        data: { id: 1, title: 'Test Post' },
+        data: { id: 1, title: "Test Post" },
         status: 200,
-        headers: {}
+        headers: {},
       };
-      
+
       mockRequestFn.mockResolvedValue(mockResponse);
-      
+
       const requestOptions = {
-        method: 'GET',
-        url: 'https://example.com/wp-json/wp/v2/posts/1',
+        method: "GET",
+        url: "https://example.com/wp-json/wp/v2/posts/1",
         headers: {},
-        params: {}
+        params: {},
       };
 
       await httpCache.request(mockRequestFn, requestOptions);
@@ -158,74 +158,74 @@ describe('HttpCacheWrapper', () => {
       expect(mockRequestFn).toHaveBeenCalledTimes(1);
 
       // Invalidate cache
-      httpCache.invalidate('posts/1');
+      httpCache.invalidate("posts/1");
 
       // Should hit API again
       await httpCache.request(mockRequestFn, requestOptions);
       expect(mockRequestFn).toHaveBeenCalledTimes(2);
     });
 
-    test('should invalidate by pattern', async () => {
+    test("should invalidate by pattern", async () => {
       // Cache multiple responses
       const responses = [
-        { url: 'posts', data: [{ id: 1 }, { id: 2 }] },
-        { url: 'posts/1', data: { id: 1 } },
-        { url: 'pages/1', data: { id: 1 } }
+        { url: "posts", data: [{ id: 1 }, { id: 2 }] },
+        { url: "posts/1", data: { id: 1 } },
+        { url: "pages/1", data: { id: 1 } },
       ];
 
       for (const response of responses) {
         mockRequestFn.mockResolvedValueOnce({
           data: response.data,
           status: 200,
-          headers: {}
+          headers: {},
         });
 
         await httpCache.request(mockRequestFn, {
-          method: 'GET',
+          method: "GET",
           url: `https://example.com/wp-json/wp/v2/${response.url}`,
           headers: {},
-          params: {}
+          params: {},
         });
       }
 
       expect(mockRequestFn).toHaveBeenCalledTimes(3);
 
       // Invalidate all posts
-      const invalidated = httpCache.invalidatePattern('posts');
+      const invalidated = httpCache.invalidatePattern("posts");
       expect(invalidated).toBe(2); // Should invalidate 2 post-related entries
 
       // Verify pages cache still works
       await httpCache.request(mockRequestFn, {
-        method: 'GET',
-        url: 'https://example.com/wp-json/wp/v2/pages/1',
+        method: "GET",
+        url: "https://example.com/wp-json/wp/v2/pages/1",
         headers: {},
-        params: {}
+        params: {},
       });
       expect(mockRequestFn).toHaveBeenCalledTimes(3); // No new call for pages
     });
 
-    test('should invalidate all cache for site', async () => {
+    test("should invalidate all cache for site", async () => {
       // Cache some responses
       const mockResponse = {
         data: { id: 1 },
         status: 200,
-        headers: {}
+        headers: {},
       };
-      
+
       mockRequestFn.mockResolvedValue(mockResponse);
 
       await httpCache.request(mockRequestFn, {
-        method: 'GET',
-        url: 'https://example.com/wp-json/wp/v2/posts',
+        method: "GET",
+        url: "https://example.com/wp-json/wp/v2/posts",
         headers: {},
-        params: {}
+        params: {},
       });
 
       await httpCache.request(mockRequestFn, {
-        method: 'GET',
-        url: 'https://example.com/wp-json/wp/v2/pages',
+        method: "GET",
+        url: "https://example.com/wp-json/wp/v2/pages",
         headers: {},
-        params: {}
+        params: {},
       });
 
       expect(mockRequestFn).toHaveBeenCalledTimes(2);
@@ -236,46 +236,49 @@ describe('HttpCacheWrapper', () => {
 
       // Verify cache is cleared
       await httpCache.request(mockRequestFn, {
-        method: 'GET',
-        url: 'https://example.com/wp-json/wp/v2/posts',
+        method: "GET",
+        url: "https://example.com/wp-json/wp/v2/posts",
         headers: {},
-        params: {}
+        params: {},
       });
       expect(mockRequestFn).toHaveBeenCalledTimes(3);
     });
   });
 
-  describe('Cache Warming', () => {
-    test('should pre-warm cache with data', () => {
-      const endpoint = 'posts';
-      const data = [{ id: 1, title: 'Post 1' }, { id: 2, title: 'Post 2' }];
+  describe("Cache Warming", () => {
+    test("should pre-warm cache with data", () => {
+      const endpoint = "posts";
+      const data = [
+        { id: 1, title: "Post 1" },
+        { id: 2, title: "Post 2" },
+      ];
       const params = { per_page: 10 };
 
       httpCache.warm(endpoint, data, params);
 
       // Verify cache entry exists
-      const cacheKey = cacheManager.generateKey('test-site', endpoint, params);
+      const cacheKey = cacheManager.generateKey("test-site", endpoint, params);
       const cached = cacheManager.get(cacheKey);
-      
+
       expect(cached).toBeDefined();
-      if (cached && typeof cached === 'object' && 'data' in cached) {
+      if (cached && typeof cached === "object" && "data" in cached) {
         expect((cached as any).data).toEqual(data);
         expect((cached as any).etag).toBeDefined();
         expect((cached as any).lastModified).toBeDefined();
       }
     });
 
-    test('should use warmed cache for requests', async () => {
-      const endpoint = 'posts';
-      const data = [{ id: 1, title: 'Post 1' }];
-      
+    test("should use warmed cache for requests", async () => {
+      const endpoint = "posts";
+      const data = [{ id: 1, title: "Post 1" }];
+
       httpCache.warm(endpoint, data);
 
       const result = await httpCache.request(mockRequestFn, {
-        method: 'GET',
-        url: 'https://example.com/wp-json/wp/v2/posts',
+        method: "GET",
+        url: "https://example.com/wp-json/wp/v2/posts",
         headers: {},
-        params: {}
+        params: {},
       });
 
       expect(mockRequestFn).not.toHaveBeenCalled();
@@ -284,29 +287,29 @@ describe('HttpCacheWrapper', () => {
     });
   });
 
-  describe('Cache Statistics', () => {
-    test('should return cache statistics', async () => {
+  describe("Cache Statistics", () => {
+    test("should return cache statistics", async () => {
       const mockResponse = {
         data: { id: 1 },
         status: 200,
-        headers: {}
+        headers: {},
       };
-      
+
       mockRequestFn.mockResolvedValue(mockResponse);
 
       // Generate some cache activity
       await httpCache.request(mockRequestFn, {
-        method: 'GET',
-        url: 'https://example.com/wp-json/wp/v2/posts/1',
+        method: "GET",
+        url: "https://example.com/wp-json/wp/v2/posts/1",
         headers: {},
-        params: {}
+        params: {},
       });
 
       await httpCache.request(mockRequestFn, {
-        method: 'GET',
-        url: 'https://example.com/wp-json/wp/v2/posts/1',
+        method: "GET",
+        url: "https://example.com/wp-json/wp/v2/posts/1",
         headers: {},
-        params: {}
+        params: {},
       });
 
       const stats = httpCache.getStats();
@@ -317,37 +320,37 @@ describe('HttpCacheWrapper', () => {
     });
   });
 
-  describe('URL and Endpoint Extraction', () => {
-    test('should extract endpoint from WordPress API URLs', async () => {
+  describe("URL and Endpoint Extraction", () => {
+    test("should extract endpoint from WordPress API URLs", async () => {
       const testCases = [
         {
-          url: 'https://example.com/wp-json/wp/v2/posts',
-          expectedEndpoint: 'posts'
+          url: "https://example.com/wp-json/wp/v2/posts",
+          expectedEndpoint: "posts",
         },
         {
-          url: 'https://example.com/wp-json/wp/v2/posts/123',
-          expectedEndpoint: 'posts/123'
+          url: "https://example.com/wp-json/wp/v2/posts/123",
+          expectedEndpoint: "posts/123",
         },
         {
-          url: 'https://example.com/wp-json/wp/v2/categories?per_page=10',
-          expectedEndpoint: 'categories'
-        }
+          url: "https://example.com/wp-json/wp/v2/categories?per_page=10",
+          expectedEndpoint: "categories",
+        },
       ];
 
       const mockResponse = {
         data: {},
         status: 200,
-        headers: {}
+        headers: {},
       };
-      
+
       mockRequestFn.mockResolvedValue(mockResponse);
 
       for (const testCase of testCases) {
         await httpCache.request(mockRequestFn, {
-          method: 'GET',
+          method: "GET",
           url: testCase.url,
           headers: {},
-          params: {}
+          params: {},
         });
 
         // Verify cache key contains the correct endpoint

package/src/cache/index.ts

@@ -3,24 +3,24 @@
  * Provides centralized access to all caching components
  */
 
-export { CacheManager, CachePresets } from './CacheManager.js';
-export { HttpCacheWrapper } from './HttpCacheWrapper.js';
-export { CacheInvalidation, WordPressCachePatterns, CacheWarmer } from './CacheInvalidation.js';
-export { CachedWordPressClient } from '../client/CachedWordPressClient.js';
+export { CacheManager, CachePresets } from "./CacheManager.js";
+export { HttpCacheWrapper } from "./HttpCacheWrapper.js";
+export {
+  CacheInvalidation,
+  WordPressCachePatterns,
+  CacheWarmer,
+} from "./CacheInvalidation.js";
+export { CachedWordPressClient } from "../client/CachedWordPressClient.js";
 
-export type {
-  CacheEntry,
-  CacheStats,
-  CacheConfig
-} from './CacheManager.js';
+export type { CacheEntry, CacheStats, CacheConfig } from "./CacheManager.js";
 
 export type {
   HttpCacheOptions,
   CachedResponse,
-  RequestOptions
-} from './HttpCacheWrapper.js';
+  RequestOptions,
+} from "./HttpCacheWrapper.js";
 
 export type {
   InvalidationRule,
-  InvalidationEvent
-} from './CacheInvalidation.js';
+  InvalidationEvent,
+} from "./CacheInvalidation.js";