mcp-wordpress 1.2.2 → 1.3.0

package/src/client/CachedWordPressClient.ts

@@ -3,16 +3,16 @@
  * Extends the base WordPress client with intelligent caching capabilities and performance monitoring
  */
 
-import { WordPressClient } from './api.js';
-import { CacheManager } from '../cache/CacheManager.js';
-import { HttpCacheWrapper } from '../cache/HttpCacheWrapper.js';
-import { CacheInvalidation } from '../cache/CacheInvalidation.js';
-import { SecurityConfig } from '../security/SecurityConfig.js';
+import { WordPressClient } from "./api.js";
+import { CacheManager } from "../cache/CacheManager.js";
+import { HttpCacheWrapper } from "../cache/HttpCacheWrapper.js";
+import { CacheInvalidation } from "../cache/CacheInvalidation.js";
+import { SecurityConfig } from "../security/SecurityConfig.js";
 import type {
   WordPressClientConfig,
   HTTPMethod,
-  RequestOptions
-} from '../types/client.js';
+  RequestOptions,
+} from "../types/client.js";
 import type {
   WordPressPost,
   WordPressUser,
@@ -21,8 +21,8 @@ import type {
   WordPressSiteSettings,
   PostQueryParams,
   CreatePostRequest,
-  UpdatePostRequest
-} from '../types/wordpress.js';
+  UpdatePostRequest,
+} from "../types/wordpress.js";
 
 /**
  * WordPress client with intelligent caching
@@ -33,17 +33,17 @@ export class CachedWordPressClient extends WordPressClient {
   private cacheInvalidation: CacheInvalidation;
   private siteId: string;
 
-  constructor(config: WordPressClientConfig, siteId: string = 'default') {
+  constructor(config: WordPressClientConfig, siteId: string = "default") {
     super(config);
     this.siteId = siteId;
-    
+
     // Initialize caching system
     this.cacheManager = new CacheManager({
       maxSize: SecurityConfig.cache.maxSize,
       defaultTTL: SecurityConfig.cache.defaultTTL,
       enableLRU: SecurityConfig.cache.enableLRU,
       enableStats: SecurityConfig.cache.enableStats,
-      sitePrefix: siteId
+      sitePrefix: siteId,
     });
 
     this.httpCache = new HttpCacheWrapper(this.cacheManager, siteId);
@@ -57,44 +57,44 @@ export class CachedWordPressClient extends WordPressClient {
     method: HTTPMethod,
     endpoint: string,
     data: any = null,
-    options: RequestOptions = {}
+    options: RequestOptions = {},
   ): Promise<T> {
     // Only cache GET requests
-    if (method.toUpperCase() !== 'GET' || !SecurityConfig.cache.enabled) {
+    if (method.toUpperCase() !== "GET" || !SecurityConfig.cache.enabled) {
       const response = await super.request<T>(method, endpoint, data, options);
-      
+
       // Trigger cache invalidation for write operations
-      if (['POST', 'PUT', 'PATCH', 'DELETE'].includes(method.toUpperCase())) {
+      if (["POST", "PUT", "PATCH", "DELETE"].includes(method.toUpperCase())) {
         await this.handleCacheInvalidation(method, endpoint, data);
       }
-      
+
       return response;
     }
 
     // Use cached request for GET operations
     const requestFn = () => super.request<T>(method, endpoint, data, options);
-    
+
     const requestOptions = {
       method,
       url: `${this.config.baseUrl}/wp-json/wp/v2/${endpoint}`,
       headers: {},
       params: {},
-      data
+      data,
     };
 
     const cacheOptions = this.getCacheOptions(endpoint);
-    
+
     const response = await this.httpCache.request(
       async () => {
         const result = await requestFn();
         return {
           data: result,
           status: 200,
-          headers: {}
+          headers: {},
         };
       },
       requestOptions,
-      cacheOptions
+      cacheOptions,
     );
 
     return response.data;
@@ -108,14 +108,16 @@ export class CachedWordPressClient extends WordPressClient {
    * Get posts with intelligent caching
    */
   async getPosts(params: PostQueryParams = {}): Promise<WordPressPost[]> {
-    return await this.request<WordPressPost[]>('GET', 'posts', null, { params });
+    return await this.request<WordPressPost[]>("GET", "posts", null, {
+      params,
+    });
   }
 
   /**
    * Get single post with caching
    */
   async getPost(id: number): Promise<WordPressPost> {
-    return await this.request<WordPressPost>('GET', `posts/${id}`);
+    return await this.request<WordPressPost>("GET", `posts/${id}`);
   }
 
   /**
@@ -123,10 +125,10 @@ export class CachedWordPressClient extends WordPressClient {
    */
   async createPost(data: CreatePostRequest): Promise<WordPressPost> {
     const post = await super.createPost(data);
-    
+
     // Invalidate related caches
-    await this.cacheInvalidation.invalidateResource('posts', post.id, 'create');
-    
+    await this.cacheInvalidation.invalidateResource("posts", post.id, "create");
+
     return post;
   }
 
@@ -135,22 +137,25 @@ export class CachedWordPressClient extends WordPressClient {
    */
   async updatePost(data: UpdatePostRequest): Promise<WordPressPost> {
     const post = await super.updatePost(data);
-    
+
     // Invalidate related caches
-    await this.cacheInvalidation.invalidateResource('posts', post.id, 'update');
-    
+    await this.cacheInvalidation.invalidateResource("posts", post.id, "update");
+
     return post;
   }
 
   /**
    * Delete post with cache invalidation
    */
-  async deletePost(id: number, force?: boolean): Promise<{ deleted: boolean; previous?: WordPressPost }> {
+  async deletePost(
+    id: number,
+    force?: boolean,
+  ): Promise<{ deleted: boolean; previous?: WordPressPost }> {
     const result = await super.deletePost(id, force);
-    
+
     // Invalidate related caches
-    await this.cacheInvalidation.invalidateResource('posts', id, 'delete');
-    
+    await this.cacheInvalidation.invalidateResource("posts", id, "delete");
+
     return result;
   }
 
@@ -158,42 +163,43 @@ export class CachedWordPressClient extends WordPressClient {
    * Get current user with session caching
    */
   async getCurrentUser(): Promise<WordPressUser> {
-    return await this.request<WordPressUser>('GET', 'users/me');
+    return await this.request<WordPressUser>("GET", "users/me");
   }
 
   /**
    * Get categories with semi-static caching
    */
   async getCategories(params: any = {}): Promise<WordPressCategory[]> {
-    return await this.request<WordPressCategory[]>('GET', 'categories', null, { params });
+    return await this.request<WordPressCategory[]>("GET", "categories", null, {
+      params,
+    });
   }
 
   /**
    * Get tags with semi-static caching
    */
   async getTags(params: any = {}): Promise<WordPressTag[]> {
-    return await this.request<WordPressTag[]>('GET', 'tags', null, { params });
+    return await this.request<WordPressTag[]>("GET", "tags", null, { params });
   }
 
   /**
    * Get site settings with static caching
    */
   async getSiteSettings(): Promise<WordPressSiteSettings> {
-    return await this.request<WordPressSiteSettings>('GET', 'settings');
+    return await this.request<WordPressSiteSettings>("GET", "settings");
   }
 
   /**
    * Cache management methods
    */
 
-
   /**
    * Private helper methods
    */
 
   private extractEndpoint(url: string): string {
     // Simple approach - use the endpoint part
-    return url.replace(/^.*\/wp-json\/wp\/v2\//, '').split('?')[0];
+    return url.replace(/^.*\/wp-json\/wp\/v2\//, "").split("?")[0];
   }
 
   /**
@@ -204,29 +210,29 @@ export class CachedWordPressClient extends WordPressClient {
     if (this.isStaticEndpoint(endpoint)) {
       return {
         ttl: SecurityConfig.cache.ttlPresets.static,
-        cacheControl: SecurityConfig.cache.cacheHeaders.static
+        cacheControl: SecurityConfig.cache.cacheHeaders.static,
       };
     }
-    
+
     if (this.isSemiStaticEndpoint(endpoint)) {
       return {
         ttl: SecurityConfig.cache.ttlPresets.semiStatic,
-        cacheControl: SecurityConfig.cache.cacheHeaders.semiStatic
+        cacheControl: SecurityConfig.cache.cacheHeaders.semiStatic,
       };
     }
-    
+
     if (this.isSessionEndpoint(endpoint)) {
       return {
         ttl: SecurityConfig.cache.ttlPresets.session,
         cacheControl: SecurityConfig.cache.cacheHeaders.session,
-        private: true
+        private: true,
       };
     }
-    
+
     // Default to dynamic caching
     return {
       ttl: SecurityConfig.cache.ttlPresets.dynamic,
-      cacheControl: SecurityConfig.cache.cacheHeaders.dynamic
+      cacheControl: SecurityConfig.cache.cacheHeaders.dynamic,
     };
   }
 
@@ -236,37 +242,41 @@ export class CachedWordPressClient extends WordPressClient {
   private async handleCacheInvalidation(
     method: string,
     endpoint: string,
-    data: any
+    data: any,
   ): Promise<void> {
     const resource = this.extractResourceFromEndpoint(endpoint);
     const id = this.extractIdFromEndpoint(endpoint);
-    
-    let operationType: 'create' | 'update' | 'delete';
-    
+
+    let operationType: "create" | "update" | "delete";
+
     switch (method.toUpperCase()) {
-    case 'POST':
-      operationType = 'create';
+    case "POST":
+      operationType = "create";
       break;
-    case 'PUT':
-    case 'PATCH':
-      operationType = 'update';
+    case "PUT":
+    case "PATCH":
+      operationType = "update";
       break;
-    case 'DELETE':
-      operationType = 'delete';
+    case "DELETE":
+      operationType = "delete";
       break;
     default:
       return;
     }
 
-    await this.cacheInvalidation.invalidateResource(resource, id, operationType);
+    await this.cacheInvalidation.invalidateResource(
+      resource,
+      id,
+      operationType,
+    );
   }
 
   /**
    * Extract resource type from endpoint
    */
   private extractResourceFromEndpoint(endpoint: string): string {
-    const parts = endpoint.split('/');
-    return parts[0] || 'unknown';
+    const parts = endpoint.split("/");
+    return parts[0] || "unknown";
   }
 
   /**
@@ -281,24 +291,24 @@ export class CachedWordPressClient extends WordPressClient {
    * Check if endpoint contains static data
    */
   private isStaticEndpoint(endpoint: string): boolean {
-    const staticEndpoints = ['settings', 'types', 'statuses'];
-    return staticEndpoints.some(pattern => endpoint.includes(pattern));
+    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));
+    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));
+    const sessionEndpoints = ["users/me", "application-passwords"];
+    return sessionEndpoints.some((pattern) => endpoint.includes(pattern));
   }
 
   /**
@@ -332,7 +342,7 @@ export class CachedWordPressClient extends WordPressClient {
    * Clear cache entries matching pattern
    */
   clearCachePattern(pattern: string): number {
-    const regex = new RegExp(pattern, 'i');
+    const regex = new RegExp(pattern, "i");
     return this.cacheManager.clearPattern(regex);
   }
 
@@ -346,11 +356,11 @@ export class CachedWordPressClient extends WordPressClient {
         () => this.getCurrentUser().catch(() => null),
         () => this.getCategories().catch(() => null),
         () => this.getTags().catch(() => null),
-        () => this.getSiteSettings().catch(() => null)
+        () => this.getSiteSettings().catch(() => null),
       ];
 
       // Execute warmup operations in parallel
-      await Promise.allSettled(warmupOperations.map(op => op()));
+      await Promise.allSettled(warmupOperations.map((op) => op()));
     } catch (_error) {
       // Ignore warmup errors - they shouldn't fail the cache warming
     }
@@ -370,18 +380,18 @@ export class CachedWordPressClient extends WordPressClient {
     const total = stats.hits + stats.misses;
     const hitRate = total > 0 ? stats.hits / total : 0;
     const missRate = 1 - hitRate;
-    
-    let efficiency = 'Poor';
-    if (hitRate >= 0.9) efficiency = 'Excellent';
-    else if (hitRate >= 0.8) efficiency = 'Good';
-    else if (hitRate >= 0.6) efficiency = 'Fair';
+
+    let efficiency = "Poor";
+    if (hitRate >= 0.9) efficiency = "Excellent";
+    else if (hitRate >= 0.8) efficiency = "Good";
+    else if (hitRate >= 0.6) efficiency = "Fair";
 
     return {
       hitRate,
       missRate,
       efficiency,
       memoryUsage: this.estimateMemoryUsage(),
-      totalEntries: stats.totalSize
+      totalEntries: stats.totalSize,
     };
   }
 
@@ -397,14 +407,14 @@ export class CachedWordPressClient extends WordPressClient {
     ttlPresets: any;
     } {
     const stats = this.cacheManager.getStats();
-    
+
     return {
       enabled: SecurityConfig.cache.enabled,
       siteId: this.siteId,
       maxSize: SecurityConfig.cache.maxSize,
       defaultTTL: SecurityConfig.cache.defaultTTL,
       currentSize: stats.totalSize,
-      ttlPresets: SecurityConfig.cache.ttlPresets
+      ttlPresets: SecurityConfig.cache.ttlPresets,
     };
   }
 
@@ -435,8 +445,8 @@ export class CachedWordPressClient extends WordPressClient {
       configuration: this.getCacheInfo(),
       siteInfo: {
         siteId: this.siteId,
-        baseUrl: this.config.baseUrl
-      }
+        baseUrl: this.config.baseUrl,
+      },
     };
   }
 }