mcp-wordpress 1.1.7 → 1.2.2

package/src/client/CachedWordPressClient.ts

@@ -0,0 +1,442 @@
+/**
+ * Cached WordPress API Client
+ * 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 type {
+  WordPressClientConfig,
+  HTTPMethod,
+  RequestOptions
+} from '../types/client.js';
+import type {
+  WordPressPost,
+  WordPressUser,
+  WordPressCategory,
+  WordPressTag,
+  WordPressSiteSettings,
+  PostQueryParams,
+  CreatePostRequest,
+  UpdatePostRequest
+} from '../types/wordpress.js';
+
+/**
+ * WordPress client with intelligent caching
+ */
+export class CachedWordPressClient extends WordPressClient {
+  private cacheManager: CacheManager;
+  private httpCache: HttpCacheWrapper;
+  private cacheInvalidation: CacheInvalidation;
+  private siteId: string;
+
+  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
+    });
+
+    this.httpCache = new HttpCacheWrapper(this.cacheManager, siteId);
+    this.cacheInvalidation = new CacheInvalidation(this.httpCache);
+  }
+
+  /**
+   * Override request method to add caching
+   */
+  async request<T = any>(
+    method: HTTPMethod,
+    endpoint: string,
+    data: any = null,
+    options: RequestOptions = {}
+  ): Promise<T> {
+    // Only cache GET requests
+    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())) {
+        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
+    };
+
+    const cacheOptions = this.getCacheOptions(endpoint);
+    
+    const response = await this.httpCache.request(
+      async () => {
+        const result = await requestFn();
+        return {
+          data: result,
+          status: 200,
+          headers: {}
+        };
+      },
+      requestOptions,
+      cacheOptions
+    );
+
+    return response.data;
+  }
+
+  /**
+   * Enhanced methods with caching optimization
+   */
+
+  /**
+   * Get posts with intelligent caching
+   */
+  async getPosts(params: PostQueryParams = {}): Promise<WordPressPost[]> {
+    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}`);
+  }
+
+  /**
+   * Create post with cache invalidation
+   */
+  async createPost(data: CreatePostRequest): Promise<WordPressPost> {
+    const post = await super.createPost(data);
+    
+    // Invalidate related caches
+    await this.cacheInvalidation.invalidateResource('posts', post.id, 'create');
+    
+    return post;
+  }
+
+  /**
+   * Update post with cache invalidation
+   */
+  async updatePost(data: UpdatePostRequest): Promise<WordPressPost> {
+    const post = await super.updatePost(data);
+    
+    // Invalidate related caches
+    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 }> {
+    const result = await super.deletePost(id, force);
+    
+    // Invalidate related caches
+    await this.cacheInvalidation.invalidateResource('posts', id, 'delete');
+    
+    return result;
+  }
+
+  /**
+   * Get current user with session caching
+   */
+  async getCurrentUser(): Promise<WordPressUser> {
+    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 });
+  }
+
+  /**
+   * Get tags with semi-static caching
+   */
+  async getTags(params: any = {}): Promise<WordPressTag[]> {
+    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');
+  }
+
+  /**
+   * 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];
+  }
+
+  /**
+   * Get cache options based on endpoint
+   */
+  private getCacheOptions(endpoint: string) {
+    // Determine cache type based on endpoint
+    if (this.isStaticEndpoint(endpoint)) {
+      return {
+        ttl: SecurityConfig.cache.ttlPresets.static,
+        cacheControl: SecurityConfig.cache.cacheHeaders.static
+      };
+    }
+    
+    if (this.isSemiStaticEndpoint(endpoint)) {
+      return {
+        ttl: SecurityConfig.cache.ttlPresets.semiStatic,
+        cacheControl: SecurityConfig.cache.cacheHeaders.semiStatic
+      };
+    }
+    
+    if (this.isSessionEndpoint(endpoint)) {
+      return {
+        ttl: SecurityConfig.cache.ttlPresets.session,
+        cacheControl: SecurityConfig.cache.cacheHeaders.session,
+        private: true
+      };
+    }
+    
+    // Default to dynamic caching
+    return {
+      ttl: SecurityConfig.cache.ttlPresets.dynamic,
+      cacheControl: SecurityConfig.cache.cacheHeaders.dynamic
+    };
+  }
+
+  /**
+   * Handle cache invalidation for write operations
+   */
+  private async handleCacheInvalidation(
+    method: string,
+    endpoint: string,
+    data: any
+  ): Promise<void> {
+    const resource = this.extractResourceFromEndpoint(endpoint);
+    const id = this.extractIdFromEndpoint(endpoint);
+    
+    let operationType: 'create' | 'update' | 'delete';
+    
+    switch (method.toUpperCase()) {
+    case 'POST':
+      operationType = 'create';
+      break;
+    case 'PUT':
+    case 'PATCH':
+      operationType = 'update';
+      break;
+    case 'DELETE':
+      operationType = 'delete';
+      break;
+    default:
+      return;
+    }
+
+    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';
+  }
+
+  /**
+   * Extract ID from endpoint
+   */
+  private extractIdFromEndpoint(endpoint: string): number | undefined {
+    const match = endpoint.match(/\/(\d+)(?:\/|$)/);
+    return match ? parseInt(match[1], 10) : undefined;
+  }
+
+  /**
+   * 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));
+  }
+
+  /**
+   * Performance monitoring and cache management methods
+   */
+
+  /**
+   * Get cache statistics for performance monitoring
+   */
+  getCacheStats(): any {
+    return this.cacheManager.getStats();
+  }
+
+  /**
+   * Get cache manager instance (for performance monitoring integration)
+   */
+  getCacheManager(): CacheManager {
+    return this.cacheManager;
+  }
+
+  /**
+   * Clear cache entries (for cache management tools)
+   */
+  clearCache(): number {
+    const stats = this.cacheManager.getStats();
+    this.cacheManager.clear();
+    return stats.totalSize;
+  }
+
+  /**
+   * Clear cache entries matching pattern
+   */
+  clearCachePattern(pattern: string): number {
+    const regex = new RegExp(pattern, 'i');
+    return this.cacheManager.clearPattern(regex);
+  }
+
+  /**
+   * Warm cache with essential data
+   */
+  async warmCache(): Promise<void> {
+    try {
+      // Pre-load frequently accessed data
+      const warmupOperations = [
+        () => this.getCurrentUser().catch(() => null),
+        () => this.getCategories().catch(() => null),
+        () => this.getTags().catch(() => null),
+        () => this.getSiteSettings().catch(() => null)
+      ];
+
+      // Execute warmup operations in parallel
+      await Promise.allSettled(warmupOperations.map(op => op()));
+    } catch (_error) {
+      // Ignore warmup errors - they shouldn't fail the cache warming
+    }
+  }
+
+  /**
+   * Get cache efficiency metrics
+   */
+  getCacheEfficiency(): {
+    hitRate: number;
+    missRate: number;
+    efficiency: string;
+    memoryUsage: number;
+    totalEntries: number;
+    } {
+    const stats = this.cacheManager.getStats();
+    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';
+
+    return {
+      hitRate,
+      missRate,
+      efficiency,
+      memoryUsage: this.estimateMemoryUsage(),
+      totalEntries: stats.totalSize
+    };
+  }
+
+  /**
+   * Get cache configuration info
+   */
+  getCacheInfo(): {
+    enabled: boolean;
+    siteId: string;
+    maxSize: number;
+    defaultTTL: number;
+    currentSize: number;
+    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
+    };
+  }
+
+  /**
+   * Estimate memory usage of cache (in MB)
+   */
+  private estimateMemoryUsage(): number {
+    const stats = this.cacheManager.getStats();
+    // Rough estimate: ~1KB per cache entry
+    return (stats.totalSize * 1024) / (1024 * 1024);
+  }
+
+  /**
+   * Get detailed cache performance metrics
+   */
+  getDetailedCacheMetrics(): {
+    statistics: any;
+    efficiency: any;
+    configuration: any;
+    siteInfo: {
+      siteId: string;
+      baseUrl: string;
+    };
+    } {
+    return {
+      statistics: this.getCacheStats(),
+      efficiency: this.getCacheEfficiency(),
+      configuration: this.getCacheInfo(),
+      siteInfo: {
+        siteId: this.siteId,
+        baseUrl: this.config.baseUrl
+      }
+    };
+  }
+}

package/src/config/ConfigurationSchema.ts

@@ -0,0 +1,246 @@
+import { z } from 'zod';
+
+/**
+ * Zod schema for WordPress authentication methods
+ */
+const AuthMethodSchema = z.enum([
+  'app-password',
+  'jwt',
+  'basic',
+  'api-key',
+  'cookie'
+] as const);
+
+/**
+ * Zod schema for URL validation
+ */
+const UrlSchema = z
+  .string()
+  .url('Must be a valid URL')
+  .refine((url) => {
+    const parsed = new URL(url);
+    return parsed.protocol === 'http:' || parsed.protocol === 'https:';
+  }, 'URL must use http or https protocol');
+
+/**
+ * Zod schema for WordPress site configuration
+ */
+const SiteConfigSchema = z.object({
+  WORDPRESS_SITE_URL: UrlSchema,
+  WORDPRESS_USERNAME: z
+    .string()
+    .min(1, 'Username is required')
+    .max(60, 'Username must be 60 characters or less')
+    .regex(/^[a-zA-Z0-9._@-]+$/, 'Username contains invalid characters'),
+  WORDPRESS_APP_PASSWORD: z
+    .string()
+    .min(1, 'Password is required')
+    .refine((password) => {
+      // WordPress app passwords are typically 24 characters with spaces
+      // But we'll be flexible to support different auth methods
+      return password.length >= 8;
+    }, 'Password must be at least 8 characters'),
+  WORDPRESS_AUTH_METHOD: AuthMethodSchema.optional().default('app-password')
+});
+
+/**
+ * Zod schema for site configuration with metadata
+ */
+const SiteSchema = z.object({
+  id: z
+    .string()
+    .min(1, 'Site ID is required')
+    .max(50, 'Site ID must be 50 characters or less')
+    .regex(
+      /^[a-zA-Z0-9_-]+$/,
+      'Site ID can only contain letters, numbers, underscores, and hyphens'
+    ),
+  name: z
+    .string()
+    .min(1, 'Site name is required')
+    .max(100, 'Site name must be 100 characters or less'),
+  config: SiteConfigSchema
+});
+
+/**
+ * Zod schema for multi-site configuration file
+ */
+const MultiSiteConfigSchema = z.object({
+  sites: z
+    .array(SiteSchema)
+    .min(1, 'At least one site must be configured')
+    .max(50, 'Maximum of 50 sites supported')
+    .refine((sites) => {
+      const ids = sites.map((site) => site.id);
+      const uniqueIds = new Set(ids);
+      return ids.length === uniqueIds.size;
+    }, 'Site IDs must be unique')
+    .refine((sites) => {
+      const names = sites.map((site) => site.name);
+      const uniqueNames = new Set(names);
+      return names.length === uniqueNames.size;
+    }, 'Site names must be unique')
+    .refine((sites) => {
+      const urls = sites.map((site) => site.config.WORDPRESS_SITE_URL);
+      const uniqueUrls = new Set(urls);
+      return urls.length === uniqueUrls.size;
+    }, 'Site URLs must be unique')
+});
+
+/**
+ * Zod schema for environment variables (single-site mode)
+ */
+const EnvironmentConfigSchema = z.object({
+  WORDPRESS_SITE_URL: UrlSchema,
+  WORDPRESS_USERNAME: SiteConfigSchema.shape.WORDPRESS_USERNAME,
+  WORDPRESS_APP_PASSWORD: SiteConfigSchema.shape.WORDPRESS_APP_PASSWORD,
+  WORDPRESS_AUTH_METHOD: AuthMethodSchema.optional().default('app-password'),
+  // Optional environment variables
+  NODE_ENV: z.enum(['development', 'production', 'test']).optional(),
+  DEBUG: z.string().optional(),
+  DISABLE_CACHE: z.string().optional(),
+  LOG_LEVEL: z.enum(['error', 'warn', 'info', 'debug']).optional()
+});
+
+/**
+ * Zod schema for MCP configuration passed from client
+ */
+const McpConfigSchema = z
+  .object({
+    wordpressSiteUrl: UrlSchema.optional(),
+    wordpressUsername: SiteConfigSchema.shape.WORDPRESS_USERNAME.optional(),
+    wordpressAppPassword:
+      SiteConfigSchema.shape.WORDPRESS_APP_PASSWORD.optional(),
+    wordpressAuthMethod: AuthMethodSchema.optional()
+  })
+  .optional();
+
+/**
+ * Type definitions derived from Zod schemas
+ */
+export type SiteConfigType = z.infer<typeof SiteConfigSchema>;
+export type SiteType = z.infer<typeof SiteSchema>;
+export type MultiSiteConfigType = z.infer<typeof MultiSiteConfigSchema>;
+export type EnvironmentConfigType = z.infer<typeof EnvironmentConfigSchema>;
+export type McpConfigType = z.infer<typeof McpConfigSchema>;
+
+/**
+ * Configuration validation utilities
+ */
+export class ConfigurationValidator {
+  /**
+   * Validate multi-site configuration from JSON file
+   */
+  static validateMultiSiteConfig(config: unknown): MultiSiteConfigType {
+    try {
+      return MultiSiteConfigSchema.parse(config);
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        const messages = error.errors
+          .map((err) => `${err.path.join('.')}: ${err.message}`)
+          .join('; ');
+        throw new Error(
+          `Multi-site configuration validation failed: ${messages}`
+        );
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Validate environment configuration for single-site mode
+   */
+  static validateEnvironmentConfig(
+    env: Record<string, string | undefined>
+  ): EnvironmentConfigType {
+    try {
+      return EnvironmentConfigSchema.parse(env);
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        const messages = error.errors
+          .map((err) => `${err.path.join('.')}: ${err.message}`)
+          .join('; ');
+        throw new Error(
+          `Environment configuration validation failed: ${messages}`
+        );
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Validate MCP configuration passed from client
+   */
+  static validateMcpConfig(config: unknown): McpConfigType {
+    try {
+      return McpConfigSchema.parse(config);
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        const messages = error.errors
+          .map((err) => `${err.path.join('.')}: ${err.message}`)
+          .join('; ');
+        throw new Error(`MCP configuration validation failed: ${messages}`);
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Validate a single site configuration
+   */
+  static validateSiteConfig(config: unknown): SiteType {
+    try {
+      return SiteSchema.parse(config);
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        const messages = error.errors
+          .map((err) => `${err.path.join('.')}: ${err.message}`)
+          .join('; ');
+        throw new Error(`Site configuration validation failed: ${messages}`);
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Check if a configuration file structure is valid without throwing
+   */
+  static isValidMultiSiteConfig(config: unknown): boolean {
+    const result = MultiSiteConfigSchema.safeParse(config);
+    return result.success;
+  }
+
+  /**
+   * Check if environment configuration is valid without throwing
+   */
+  static isValidEnvironmentConfig(
+    env: Record<string, string | undefined>
+  ): boolean {
+    const result = EnvironmentConfigSchema.safeParse(env);
+    return result.success;
+  }
+
+  /**
+   * Get validation errors without throwing
+   */
+  static getValidationErrors(schema: z.ZodSchema, data: unknown): string[] {
+    const result = schema.safeParse(data);
+    if (result.success) {
+      return [];
+    }
+    return result.error.errors.map(
+      (err) => `${err.path.join('.')}: ${err.message}`
+    );
+  }
+}
+
+// Export schemas for direct use if needed
+export {
+  SiteConfigSchema,
+  SiteSchema,
+  MultiSiteConfigSchema,
+  EnvironmentConfigSchema,
+  McpConfigSchema,
+  AuthMethodSchema,
+  UrlSchema
+};