@jgardner04/ghost-mcp-server 1.9.0 → 1.11.0

package/src/services/__tests__/ghostServiceImproved.tiers.test.js

@@ -0,0 +1,392 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createMockContextLogger } from '../../__tests__/helpers/mockLogger.js';
+import { mockDotenv } from '../../__tests__/helpers/testUtils.js';
+
+// Mock the Ghost Admin API with tiers support
+vi.mock('@tryghost/admin-api', () => ({
+  default: vi.fn(function () {
+    return {
+      posts: {
+        add: vi.fn(),
+        browse: vi.fn(),
+        read: vi.fn(),
+        edit: vi.fn(),
+        delete: vi.fn(),
+      },
+      pages: {
+        add: vi.fn(),
+        browse: vi.fn(),
+        read: vi.fn(),
+        edit: vi.fn(),
+        delete: vi.fn(),
+      },
+      tags: {
+        add: vi.fn(),
+        browse: vi.fn(),
+        read: vi.fn(),
+        edit: vi.fn(),
+        delete: vi.fn(),
+      },
+      members: {
+        add: vi.fn(),
+        browse: vi.fn(),
+        read: vi.fn(),
+        edit: vi.fn(),
+        delete: vi.fn(),
+      },
+      tiers: {
+        add: vi.fn(),
+        browse: vi.fn(),
+        read: vi.fn(),
+        edit: vi.fn(),
+        delete: vi.fn(),
+      },
+      site: {
+        read: vi.fn(),
+      },
+      images: {
+        upload: vi.fn(),
+      },
+    };
+  }),
+}));
+
+// Mock dotenv
+vi.mock('dotenv', () => mockDotenv());
+
+// Mock logger
+vi.mock('../../utils/logger.js', () => ({
+  createContextLogger: createMockContextLogger(),
+}));
+
+// Mock fs for validateImagePath
+vi.mock('fs/promises', () => ({
+  default: {
+    access: vi.fn(),
+  },
+}));
+
+// Import after setting up mocks
+import {
+  createTier,
+  updateTier,
+  deleteTier,
+  getTiers,
+  getTier,
+  api,
+} from '../ghostServiceImproved.js';
+
+describe('ghostServiceImproved - Tiers', () => {
+  beforeEach(() => {
+    // Reset all mocks before each test
+    vi.clearAllMocks();
+  });
+
+  describe('createTier', () => {
+    it('should create a tier with required fields', async () => {
+      const tierData = {
+        name: 'Premium',
+        currency: 'USD',
+      };
+
+      const mockCreatedTier = {
+        id: 'tier-1',
+        name: 'Premium',
+        currency: 'USD',
+        type: 'paid',
+        active: true,
+      };
+
+      api.tiers.add.mockResolvedValue(mockCreatedTier);
+
+      const result = await createTier(tierData);
+
+      expect(api.tiers.add).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: 'Premium',
+          currency: 'USD',
+        }),
+        expect.any(Object)
+      );
+      expect(result).toEqual(mockCreatedTier);
+    });
+
+    it('should create a tier with all optional fields', async () => {
+      const tierData = {
+        name: 'Premium Membership',
+        currency: 'USD',
+        description: 'Access to premium content',
+        monthly_price: 999,
+        yearly_price: 9999,
+        benefits: ['Ad-free experience', 'Exclusive content'],
+        welcome_page_url: 'https://example.com/welcome',
+      };
+
+      const mockCreatedTier = {
+        id: 'tier-2',
+        ...tierData,
+        type: 'paid',
+        active: true,
+      };
+
+      api.tiers.add.mockResolvedValue(mockCreatedTier);
+
+      const result = await createTier(tierData);
+
+      expect(api.tiers.add).toHaveBeenCalledWith(
+        expect.objectContaining(tierData),
+        expect.any(Object)
+      );
+      expect(result).toEqual(mockCreatedTier);
+    });
+
+    it('should throw ValidationError when name is missing', async () => {
+      await expect(
+        createTier({
+          currency: 'USD',
+        })
+      ).rejects.toThrow('Tier validation failed');
+    });
+
+    it('should throw ValidationError when currency is missing', async () => {
+      await expect(
+        createTier({
+          name: 'Premium',
+        })
+      ).rejects.toThrow('Tier validation failed');
+    });
+
+    it('should throw ValidationError when currency is invalid', async () => {
+      await expect(
+        createTier({
+          name: 'Premium',
+          currency: 'us',
+        })
+      ).rejects.toThrow('Tier validation failed');
+    });
+  });
+
+  describe('getTiers', () => {
+    it('should get all tiers with default options', async () => {
+      const mockTiers = [
+        {
+          id: 'tier-1',
+          name: 'Free',
+          type: 'free',
+          active: true,
+        },
+        {
+          id: 'tier-2',
+          name: 'Premium',
+          type: 'paid',
+          active: true,
+        },
+      ];
+
+      api.tiers.browse.mockResolvedValue(mockTiers);
+
+      const result = await getTiers();
+
+      expect(api.tiers.browse).toHaveBeenCalledWith(
+        expect.objectContaining({
+          limit: 15,
+        }),
+        expect.any(Object)
+      );
+      expect(result).toEqual(mockTiers);
+    });
+
+    it('should get tiers with custom limit', async () => {
+      const mockTiers = [
+        {
+          id: 'tier-1',
+          name: 'Free',
+          type: 'free',
+          active: true,
+        },
+      ];
+
+      api.tiers.browse.mockResolvedValue(mockTiers);
+
+      const result = await getTiers({ limit: 5 });
+
+      expect(api.tiers.browse).toHaveBeenCalledWith(
+        expect.objectContaining({
+          limit: 5,
+        }),
+        expect.any(Object)
+      );
+      expect(result).toEqual(mockTiers);
+    });
+
+    it('should get tiers with filter', async () => {
+      const mockTiers = [
+        {
+          id: 'tier-2',
+          name: 'Premium',
+          type: 'paid',
+          active: true,
+        },
+      ];
+
+      api.tiers.browse.mockResolvedValue(mockTiers);
+
+      const result = await getTiers({ filter: 'type:paid' });
+
+      expect(api.tiers.browse).toHaveBeenCalledWith(
+        expect.objectContaining({
+          filter: 'type:paid',
+        }),
+        expect.any(Object)
+      );
+      expect(result).toEqual(mockTiers);
+    });
+
+    it('should return empty array when no tiers found', async () => {
+      api.tiers.browse.mockResolvedValue([]);
+
+      const result = await getTiers();
+
+      expect(result).toEqual([]);
+    });
+
+    it('should throw ValidationError for invalid limit', async () => {
+      await expect(getTiers({ limit: 0 })).rejects.toThrow('Tier query validation failed');
+      await expect(getTiers({ limit: 101 })).rejects.toThrow('Tier query validation failed');
+    });
+  });
+
+  describe('getTier', () => {
+    it('should get a single tier by ID', async () => {
+      const mockTier = {
+        id: 'tier-1',
+        name: 'Premium',
+        currency: 'USD',
+        type: 'paid',
+        active: true,
+      };
+
+      api.tiers.read.mockResolvedValue(mockTier);
+
+      const result = await getTier('tier-1');
+
+      expect(api.tiers.read).toHaveBeenCalledWith(
+        expect.objectContaining({
+          id: 'tier-1',
+        }),
+        expect.objectContaining({
+          id: 'tier-1',
+        })
+      );
+      expect(result).toEqual(mockTier);
+    });
+
+    it('should throw ValidationError when ID is missing', async () => {
+      await expect(getTier()).rejects.toThrow('Tier ID is required');
+    });
+
+    it('should throw ValidationError when ID is empty string', async () => {
+      await expect(getTier('')).rejects.toThrow('Tier ID is required');
+    });
+
+    it('should throw NotFoundError when tier does not exist', async () => {
+      const mockError = new Error('Tier not found');
+      mockError.response = { status: 404 };
+
+      api.tiers.read.mockRejectedValue(mockError);
+
+      await expect(getTier('nonexistent-id')).rejects.toThrow();
+    });
+  });
+
+  describe('updateTier', () => {
+    it('should update a tier', async () => {
+      const existingTier = {
+        id: 'tier-1',
+        name: 'Premium',
+        currency: 'USD',
+        monthly_price: 999,
+        updated_at: '2024-01-01T00:00:00.000Z',
+      };
+
+      const updateData = {
+        name: 'Premium Plus',
+        monthly_price: 1299,
+      };
+
+      const mockUpdatedTier = {
+        ...existingTier,
+        ...updateData,
+      };
+
+      api.tiers.read.mockResolvedValue(existingTier);
+      api.tiers.edit.mockResolvedValue(mockUpdatedTier);
+
+      const result = await updateTier('tier-1', updateData);
+
+      expect(api.tiers.read).toHaveBeenCalledWith(
+        expect.objectContaining({ id: 'tier-1' }),
+        expect.objectContaining({ id: 'tier-1' })
+      );
+      expect(api.tiers.edit).toHaveBeenCalledWith(
+        expect.objectContaining({
+          ...existingTier,
+          ...updateData,
+        }),
+        expect.objectContaining({
+          id: 'tier-1',
+        })
+      );
+      expect(result).toEqual(mockUpdatedTier);
+    });
+
+    it('should throw ValidationError when ID is missing', async () => {
+      await expect(updateTier('', { name: 'Updated' })).rejects.toThrow(
+        'Tier ID is required for update'
+      );
+    });
+
+    it('should throw ValidationError for invalid update data', async () => {
+      await expect(updateTier('tier-1', { monthly_price: -100 })).rejects.toThrow(
+        'Tier validation failed'
+      );
+    });
+
+    it('should throw NotFoundError when tier does not exist', async () => {
+      const mockError = new Error('Tier not found');
+      mockError.response = { status: 404 };
+
+      api.tiers.read.mockRejectedValue(mockError);
+
+      await expect(updateTier('nonexistent-id', { name: 'Updated' })).rejects.toThrow();
+    });
+  });
+
+  describe('deleteTier', () => {
+    it('should delete a tier', async () => {
+      api.tiers.delete.mockResolvedValue({ success: true });
+
+      const result = await deleteTier('tier-1');
+
+      expect(api.tiers.delete).toHaveBeenCalledWith('tier-1', expect.any(Object));
+      expect(result).toEqual({ success: true });
+    });
+
+    it('should throw ValidationError when ID is missing', async () => {
+      await expect(deleteTier()).rejects.toThrow('Tier ID is required for deletion');
+    });
+
+    it('should throw ValidationError when ID is empty string', async () => {
+      await expect(deleteTier('')).rejects.toThrow('Tier ID is required for deletion');
+    });
+
+    it('should throw NotFoundError when tier does not exist', async () => {
+      const mockError = new Error('Tier not found');
+      mockError.response = { status: 404 };
+
+      api.tiers.delete.mockRejectedValue(mockError);
+
+      await expect(deleteTier('nonexistent-id')).rejects.toThrow();
+    });
+  });
+});

package/src/services/__tests__/memberService.test.js

@@ -1,5 +1,13 @@
 import { describe, it, expect } from 'vitest';
-import { validateMemberData, validateMemberUpdateData } from '../memberService.js';
+import {
+  validateMemberData,
+  validateMemberUpdateData,
+  validateMemberQueryOptions,
+  validateMemberLookup,
+  validateSearchQuery,
+  validateSearchOptions,
+  sanitizeNqlValue,
+} from '../memberService.js';
 
 describe('memberService - Validation', () => {
   describe('validateMemberData', () => {
@@ -242,4 +250,228 @@ describe('memberService - Validation', () => {
       );
     });
   });
+
+  describe('validateMemberQueryOptions', () => {
+    it('should accept empty options', () => {
+      expect(() => validateMemberQueryOptions({})).not.toThrow();
+    });
+
+    it('should accept valid limit within bounds', () => {
+      expect(() => validateMemberQueryOptions({ limit: 1 })).not.toThrow();
+      expect(() => validateMemberQueryOptions({ limit: 50 })).not.toThrow();
+      expect(() => validateMemberQueryOptions({ limit: 100 })).not.toThrow();
+    });
+
+    it('should reject limit below minimum', () => {
+      expect(() => validateMemberQueryOptions({ limit: 0 })).toThrow(
+        'Member query validation failed'
+      );
+      expect(() => validateMemberQueryOptions({ limit: -1 })).toThrow(
+        'Member query validation failed'
+      );
+    });
+
+    it('should reject limit above maximum', () => {
+      expect(() => validateMemberQueryOptions({ limit: 101 })).toThrow(
+        'Member query validation failed'
+      );
+    });
+
+    it('should accept valid page number', () => {
+      expect(() => validateMemberQueryOptions({ page: 1 })).not.toThrow();
+      expect(() => validateMemberQueryOptions({ page: 100 })).not.toThrow();
+    });
+
+    it('should reject page below minimum', () => {
+      expect(() => validateMemberQueryOptions({ page: 0 })).toThrow(
+        'Member query validation failed'
+      );
+      expect(() => validateMemberQueryOptions({ page: -1 })).toThrow(
+        'Member query validation failed'
+      );
+    });
+
+    it('should accept valid filter strings', () => {
+      expect(() => validateMemberQueryOptions({ filter: 'status:free' })).not.toThrow();
+      expect(() => validateMemberQueryOptions({ filter: 'status:paid' })).not.toThrow();
+      expect(() => validateMemberQueryOptions({ filter: 'subscribed:true' })).not.toThrow();
+    });
+
+    it('should reject empty filter string', () => {
+      expect(() => validateMemberQueryOptions({ filter: '' })).toThrow(
+        'Member query validation failed'
+      );
+      expect(() => validateMemberQueryOptions({ filter: '   ' })).toThrow(
+        'Member query validation failed'
+      );
+    });
+
+    it('should accept valid order strings', () => {
+      expect(() => validateMemberQueryOptions({ order: 'created_at desc' })).not.toThrow();
+      expect(() => validateMemberQueryOptions({ order: 'email asc' })).not.toThrow();
+    });
+
+    it('should reject empty order string', () => {
+      expect(() => validateMemberQueryOptions({ order: '' })).toThrow(
+        'Member query validation failed'
+      );
+    });
+
+    it('should accept valid include strings', () => {
+      expect(() => validateMemberQueryOptions({ include: 'labels' })).not.toThrow();
+      expect(() => validateMemberQueryOptions({ include: 'newsletters' })).not.toThrow();
+      expect(() => validateMemberQueryOptions({ include: 'labels,newsletters' })).not.toThrow();
+    });
+
+    it('should reject empty include string', () => {
+      expect(() => validateMemberQueryOptions({ include: '' })).toThrow(
+        'Member query validation failed'
+      );
+    });
+
+    it('should validate multiple options together', () => {
+      expect(() =>
+        validateMemberQueryOptions({
+          limit: 50,
+          page: 2,
+          filter: 'status:paid',
+          order: 'created_at desc',
+          include: 'labels,newsletters',
+        })
+      ).not.toThrow();
+    });
+  });
+
+  describe('validateMemberLookup', () => {
+    it('should accept valid id', () => {
+      expect(() => validateMemberLookup({ id: '12345' })).not.toThrow();
+    });
+
+    it('should accept valid email', () => {
+      expect(() => validateMemberLookup({ email: 'test@example.com' })).not.toThrow();
+    });
+
+    it('should reject when both id and email are missing', () => {
+      expect(() => validateMemberLookup({})).toThrow('Member lookup validation failed');
+    });
+
+    it('should reject empty id', () => {
+      expect(() => validateMemberLookup({ id: '' })).toThrow('Member lookup validation failed');
+      expect(() => validateMemberLookup({ id: '   ' })).toThrow('Member lookup validation failed');
+    });
+
+    it('should reject invalid email format', () => {
+      expect(() => validateMemberLookup({ email: 'invalid-email' })).toThrow(
+        'Member lookup validation failed'
+      );
+      expect(() => validateMemberLookup({ email: 'test@' })).toThrow(
+        'Member lookup validation failed'
+      );
+    });
+
+    it('should accept when both id and email provided (id takes precedence)', () => {
+      expect(() => validateMemberLookup({ id: '12345', email: 'test@example.com' })).not.toThrow();
+    });
+
+    it('should return normalized params with lookupType', () => {
+      const resultId = validateMemberLookup({ id: '12345' });
+      expect(resultId).toEqual({ id: '12345', lookupType: 'id' });
+
+      const resultEmail = validateMemberLookup({ email: 'test@example.com' });
+      expect(resultEmail).toEqual({ email: 'test@example.com', lookupType: 'email' });
+
+      // ID takes precedence when both provided
+      const resultBoth = validateMemberLookup({ id: '12345', email: 'test@example.com' });
+      expect(resultBoth).toEqual({ id: '12345', lookupType: 'id' });
+    });
+  });
+
+  describe('validateSearchQuery', () => {
+    it('should accept valid search query', () => {
+      expect(() => validateSearchQuery('john')).not.toThrow();
+      expect(() => validateSearchQuery('john@example.com')).not.toThrow();
+    });
+
+    it('should reject empty search query', () => {
+      expect(() => validateSearchQuery('')).toThrow('Search query validation failed');
+      expect(() => validateSearchQuery('   ')).toThrow('Search query validation failed');
+    });
+
+    it('should reject non-string search query', () => {
+      expect(() => validateSearchQuery(123)).toThrow('Search query validation failed');
+      expect(() => validateSearchQuery(null)).toThrow('Search query validation failed');
+      expect(() => validateSearchQuery(undefined)).toThrow('Search query validation failed');
+    });
+
+    it('should return sanitized query', () => {
+      const result = validateSearchQuery('john');
+      expect(result).toBe('john');
+    });
+
+    it('should trim whitespace from query', () => {
+      const result = validateSearchQuery('  john  ');
+      expect(result).toBe('john');
+    });
+  });
+
+  describe('validateSearchOptions', () => {
+    it('should accept empty options', () => {
+      expect(() => validateSearchOptions({})).not.toThrow();
+    });
+
+    it('should accept valid limit within bounds (1-50)', () => {
+      expect(() => validateSearchOptions({ limit: 1 })).not.toThrow();
+      expect(() => validateSearchOptions({ limit: 25 })).not.toThrow();
+      expect(() => validateSearchOptions({ limit: 50 })).not.toThrow();
+    });
+
+    it('should reject limit below minimum', () => {
+      expect(() => validateSearchOptions({ limit: 0 })).toThrow('Search options validation failed');
+      expect(() => validateSearchOptions({ limit: -1 })).toThrow(
+        'Search options validation failed'
+      );
+    });
+
+    it('should reject limit above maximum (50)', () => {
+      expect(() => validateSearchOptions({ limit: 51 })).toThrow(
+        'Search options validation failed'
+      );
+      expect(() => validateSearchOptions({ limit: 100 })).toThrow(
+        'Search options validation failed'
+      );
+    });
+
+    it('should reject non-number limit', () => {
+      expect(() => validateSearchOptions({ limit: 'ten' })).toThrow(
+        'Search options validation failed'
+      );
+    });
+  });
+
+  describe('sanitizeNqlValue', () => {
+    it('should escape backslashes', () => {
+      expect(sanitizeNqlValue('test\\value')).toBe('test\\\\value');
+    });
+
+    it('should escape single quotes', () => {
+      expect(sanitizeNqlValue("test'value")).toBe("test\\'value");
+    });
+
+    it('should escape double quotes', () => {
+      expect(sanitizeNqlValue('test"value')).toBe('test\\"value');
+    });
+
+    it('should handle multiple special characters', () => {
+      expect(sanitizeNqlValue('test\'value"with\\chars')).toBe('test\\\'value\\"with\\\\chars');
+    });
+
+    it('should not modify strings without special characters', () => {
+      expect(sanitizeNqlValue('normalvalue')).toBe('normalvalue');
+      expect(sanitizeNqlValue('test@example.com')).toBe('test@example.com');
+    });
+
+    it('should handle empty string', () => {
+      expect(sanitizeNqlValue('')).toBe('');
+    });
+  });
 });