@jgardner04/ghost-mcp-server 1.9.0 → 1.11.0

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

@@ -0,0 +1,372 @@
+import { describe, it, expect } from 'vitest';
+import {
+  validateTierData,
+  validateTierUpdateData,
+  validateTierQueryOptions,
+  sanitizeNqlValue,
+} from '../tierService.js';
+import { ValidationError } from '../../errors/index.js';
+
+describe('tierService - Validation', () => {
+  describe('validateTierData', () => {
+    it('should validate required name field', () => {
+      expect(() => validateTierData({})).toThrow(ValidationError);
+      expect(() => validateTierData({})).toThrow('Tier validation failed');
+    });
+
+    it('should validate required currency field', () => {
+      expect(() => validateTierData({ name: 'Premium' })).toThrow(ValidationError);
+      expect(() => validateTierData({ name: 'Premium' })).toThrow('Tier validation failed');
+    });
+
+    it('should accept valid tier data with name and currency', () => {
+      expect(() =>
+        validateTierData({
+          name: 'Premium',
+          currency: 'USD',
+        })
+      ).not.toThrow();
+    });
+
+    it('should validate name is a non-empty string', () => {
+      expect(() =>
+        validateTierData({
+          name: '',
+          currency: 'USD',
+        })
+      ).toThrow('Tier validation failed');
+    });
+
+    it('should validate name does not exceed max length', () => {
+      const longName = 'a'.repeat(192);
+      expect(() =>
+        validateTierData({
+          name: longName,
+          currency: 'USD',
+        })
+      ).toThrow('Tier validation failed');
+    });
+
+    it('should validate currency is a 3-letter uppercase code', () => {
+      expect(() =>
+        validateTierData({
+          name: 'Premium',
+          currency: 'us',
+        })
+      ).toThrow('Tier validation failed');
+
+      expect(() =>
+        validateTierData({
+          name: 'Premium',
+          currency: 'USDD',
+        })
+      ).toThrow('Tier validation failed');
+
+      expect(() =>
+        validateTierData({
+          name: 'Premium',
+          currency: '123',
+        })
+      ).toThrow('Tier validation failed');
+    });
+
+    it('should validate description does not exceed max length', () => {
+      const longDescription = 'a'.repeat(2001);
+      expect(() =>
+        validateTierData({
+          name: 'Premium',
+          currency: 'USD',
+          description: longDescription,
+        })
+      ).toThrow('Tier validation failed');
+    });
+
+    it('should validate monthly_price is a non-negative number', () => {
+      expect(() =>
+        validateTierData({
+          name: 'Premium',
+          currency: 'USD',
+          monthly_price: -100,
+        })
+      ).toThrow('Tier validation failed');
+
+      expect(() =>
+        validateTierData({
+          name: 'Premium',
+          currency: 'USD',
+          monthly_price: 'invalid',
+        })
+      ).toThrow('Tier validation failed');
+    });
+
+    it('should validate yearly_price is a non-negative number', () => {
+      expect(() =>
+        validateTierData({
+          name: 'Premium',
+          currency: 'USD',
+          yearly_price: -1000,
+        })
+      ).toThrow('Tier validation failed');
+
+      expect(() =>
+        validateTierData({
+          name: 'Premium',
+          currency: 'USD',
+          yearly_price: 'invalid',
+        })
+      ).toThrow('Tier validation failed');
+    });
+
+    it('should validate benefits is an array of strings', () => {
+      expect(() =>
+        validateTierData({
+          name: 'Premium',
+          currency: 'USD',
+          benefits: 'not an array',
+        })
+      ).toThrow('Tier validation failed');
+
+      expect(() =>
+        validateTierData({
+          name: 'Premium',
+          currency: 'USD',
+          benefits: [123, 456],
+        })
+      ).toThrow('Tier validation failed');
+
+      expect(() =>
+        validateTierData({
+          name: 'Premium',
+          currency: 'USD',
+          benefits: ['Benefit 1', ''],
+        })
+      ).toThrow('Tier validation failed');
+    });
+
+    it('should validate welcome_page_url is a valid URL', () => {
+      expect(() =>
+        validateTierData({
+          name: 'Premium',
+          currency: 'USD',
+          welcome_page_url: 'not-a-url',
+        })
+      ).toThrow('Tier validation failed');
+
+      expect(() =>
+        validateTierData({
+          name: 'Premium',
+          currency: 'USD',
+          welcome_page_url: 'ftp://example.com',
+        })
+      ).toThrow('Tier validation failed');
+    });
+
+    it('should accept valid welcome_page_url', () => {
+      expect(() =>
+        validateTierData({
+          name: 'Premium',
+          currency: 'USD',
+          welcome_page_url: 'https://example.com/welcome',
+        })
+      ).not.toThrow();
+
+      expect(() =>
+        validateTierData({
+          name: 'Premium',
+          currency: 'USD',
+          welcome_page_url: 'http://example.com/welcome',
+        })
+      ).not.toThrow();
+    });
+
+    it('should accept complete valid tier data', () => {
+      expect(() =>
+        validateTierData({
+          name: 'Premium Membership',
+          description: 'Access to premium content',
+          currency: 'USD',
+          monthly_price: 999,
+          yearly_price: 9999,
+          benefits: ['Ad-free experience', 'Exclusive content', 'Priority support'],
+          welcome_page_url: 'https://example.com/welcome',
+        })
+      ).not.toThrow();
+    });
+  });
+
+  describe('validateTierUpdateData', () => {
+    it('should accept empty update data', () => {
+      expect(() => validateTierUpdateData({})).not.toThrow();
+    });
+
+    it('should validate name if provided', () => {
+      expect(() =>
+        validateTierUpdateData({
+          name: '',
+        })
+      ).toThrow('Tier validation failed');
+    });
+
+    it('should validate currency if provided', () => {
+      expect(() =>
+        validateTierUpdateData({
+          currency: 'us',
+        })
+      ).toThrow('Tier validation failed');
+    });
+
+    it('should validate description length if provided', () => {
+      const longDescription = 'a'.repeat(2001);
+      expect(() =>
+        validateTierUpdateData({
+          description: longDescription,
+        })
+      ).toThrow('Tier validation failed');
+    });
+
+    it('should validate monthly_price if provided', () => {
+      expect(() =>
+        validateTierUpdateData({
+          monthly_price: -100,
+        })
+      ).toThrow('Tier validation failed');
+    });
+
+    it('should validate yearly_price if provided', () => {
+      expect(() =>
+        validateTierUpdateData({
+          yearly_price: -1000,
+        })
+      ).toThrow('Tier validation failed');
+    });
+
+    it('should validate benefits if provided', () => {
+      expect(() =>
+        validateTierUpdateData({
+          benefits: 'not an array',
+        })
+      ).toThrow('Tier validation failed');
+    });
+
+    it('should validate welcome_page_url if provided', () => {
+      expect(() =>
+        validateTierUpdateData({
+          welcome_page_url: 'not-a-url',
+        })
+      ).toThrow('Tier validation failed');
+    });
+
+    it('should accept valid update data', () => {
+      expect(() =>
+        validateTierUpdateData({
+          name: 'Updated Premium',
+          monthly_price: 1299,
+          benefits: ['New benefit'],
+        })
+      ).not.toThrow();
+    });
+  });
+
+  describe('validateTierQueryOptions', () => {
+    it('should accept empty options', () => {
+      expect(() => validateTierQueryOptions({})).not.toThrow();
+    });
+
+    it('should validate limit is within range', () => {
+      expect(() => validateTierQueryOptions({ limit: 0 })).toThrow('Tier query validation failed');
+
+      expect(() => validateTierQueryOptions({ limit: 101 })).toThrow(
+        'Tier query validation failed'
+      );
+
+      expect(() => validateTierQueryOptions({ limit: 50 })).not.toThrow();
+    });
+
+    it('should validate limit is a number', () => {
+      expect(() => validateTierQueryOptions({ limit: 'invalid' })).toThrow(
+        'Tier query validation failed'
+      );
+    });
+
+    it('should validate page is >= 1', () => {
+      expect(() => validateTierQueryOptions({ page: 0 })).toThrow('Tier query validation failed');
+
+      expect(() => validateTierQueryOptions({ page: -1 })).toThrow('Tier query validation failed');
+
+      expect(() => validateTierQueryOptions({ page: 1 })).not.toThrow();
+    });
+
+    it('should validate page is a number', () => {
+      expect(() => validateTierQueryOptions({ page: 'invalid' })).toThrow(
+        'Tier query validation failed'
+      );
+    });
+
+    it('should validate filter is a non-empty string', () => {
+      expect(() => validateTierQueryOptions({ filter: '' })).toThrow(
+        'Tier query validation failed'
+      );
+
+      expect(() => validateTierQueryOptions({ filter: '   ' })).toThrow(
+        'Tier query validation failed'
+      );
+
+      expect(() => validateTierQueryOptions({ filter: 'type:paid' })).not.toThrow();
+    });
+
+    it('should validate order is a non-empty string', () => {
+      expect(() => validateTierQueryOptions({ order: '' })).toThrow('Tier query validation failed');
+
+      expect(() => validateTierQueryOptions({ order: 'created_at desc' })).not.toThrow();
+    });
+
+    it('should validate include is a non-empty string', () => {
+      expect(() => validateTierQueryOptions({ include: '' })).toThrow(
+        'Tier query validation failed'
+      );
+
+      expect(() =>
+        validateTierQueryOptions({ include: 'monthly_price,yearly_price' })
+      ).not.toThrow();
+    });
+
+    it('should accept valid query options', () => {
+      expect(() =>
+        validateTierQueryOptions({
+          limit: 50,
+          page: 2,
+          filter: 'type:paid',
+          order: 'created_at desc',
+          include: 'monthly_price,yearly_price',
+        })
+      ).not.toThrow();
+    });
+  });
+
+  describe('sanitizeNqlValue', () => {
+    it('should return value if undefined or null', () => {
+      expect(sanitizeNqlValue(null)).toBe(null);
+      expect(sanitizeNqlValue(undefined)).toBe(undefined);
+    });
+
+    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 escape multiple special characters', () => {
+      expect(sanitizeNqlValue('test\\value"with\'quotes')).toBe('test\\\\value\\"with\\\'quotes');
+    });
+
+    it('should handle strings without special characters', () => {
+      expect(sanitizeNqlValue('simple-value')).toBe('simple-value');
+    });
+  });
+});

package/src/services/ghostServiceImproved.js

@@ -876,6 +876,111 @@ export async function deleteMember(memberId) {
   }
 }
 
+/**
+ * List members from Ghost CMS with optional filtering and pagination
+ * @param {Object} [options] - Query options
+ * @param {number} [options.limit] - Number of members to return (1-100)
+ * @param {number} [options.page] - Page number (1+)
+ * @param {string} [options.filter] - NQL filter string (e.g., 'status:paid')
+ * @param {string} [options.order] - Order string (e.g., 'created_at desc')
+ * @param {string} [options.include] - Include string (e.g., 'labels,newsletters')
+ * @returns {Promise<Array>} Array of member objects
+ * @throws {ValidationError} If validation fails
+ * @throws {GhostAPIError} If the API request fails
+ */
+export async function getMembers(options = {}) {
+  // Import and validate query options
+  const { validateMemberQueryOptions } = await import('./memberService.js');
+  validateMemberQueryOptions(options);
+
+  const defaultOptions = {
+    limit: 15,
+    ...options,
+  };
+
+  try {
+    const members = await handleApiRequest('members', 'browse', {}, defaultOptions);
+    return members || [];
+  } catch (error) {
+    console.error('Failed to get members:', error);
+    throw error;
+  }
+}
+
+/**
+ * Get a single member from Ghost CMS by ID or email
+ * @param {Object} params - Lookup parameters (id OR email required)
+ * @param {string} [params.id] - Member ID
+ * @param {string} [params.email] - Member email
+ * @returns {Promise<Object>} The member object
+ * @throws {ValidationError} If validation fails
+ * @throws {NotFoundError} If the member is not found
+ * @throws {GhostAPIError} If the API request fails
+ */
+export async function getMember(params) {
+  // Import and validate lookup parameters
+  const { validateMemberLookup, sanitizeNqlValue } = await import('./memberService.js');
+  const { lookupType, id, email } = validateMemberLookup(params);
+
+  try {
+    if (lookupType === 'id') {
+      // Lookup by ID using read endpoint
+      return await handleApiRequest('members', 'read', { id }, { id });
+    } else {
+      // Lookup by email using browse with filter
+      const sanitizedEmail = sanitizeNqlValue(email);
+      const members = await handleApiRequest(
+        'members',
+        'browse',
+        {},
+        { filter: `email:'${sanitizedEmail}'`, limit: 1 }
+      );
+
+      if (!members || members.length === 0) {
+        throw new NotFoundError('Member', email);
+      }
+
+      return members[0];
+    }
+  } catch (error) {
+    if (error instanceof GhostAPIError && error.ghostStatusCode === 404) {
+      throw new NotFoundError('Member', id || email);
+    }
+    throw error;
+  }
+}
+
+/**
+ * Search members by name or email
+ * @param {string} query - Search query (searches name and email fields)
+ * @param {Object} [options] - Additional options
+ * @param {number} [options.limit] - Maximum number of results (default: 15)
+ * @returns {Promise<Array>} Array of matching member objects
+ * @throws {ValidationError} If validation fails
+ * @throws {GhostAPIError} If the API request fails
+ */
+export async function searchMembers(query, options = {}) {
+  // Import and validate search query and options
+  const { validateSearchQuery, validateSearchOptions, sanitizeNqlValue } =
+    await import('./memberService.js');
+  validateSearchOptions(options);
+  const sanitizedQuery = sanitizeNqlValue(validateSearchQuery(query));
+
+  const limit = options.limit || 15;
+
+  // Build NQL filter for name or email containing the query
+  // Ghost uses ~ for contains/like matching
+  const filter = `name:~'${sanitizedQuery}',email:~'${sanitizedQuery}'`;
+
+  try {
+    const members = await handleApiRequest('members', 'browse', {}, { filter, limit });
+    return members || [];
+  } catch (error) {
+    console.error('Failed to search members:', error);
+    throw error;
+  }
+}
+
 /**
  * Newsletter CRUD Operations
  */
@@ -973,6 +1078,131 @@ export async function deleteNewsletter(newsletterId) {
   }
 }
 
+/**
+ * Create a new tier (membership level)
+ * @param {Object} tierData - Tier data
+ * @param {Object} [options={}] - Options for the API request
+ * @returns {Promise<Object>} Created tier
+ */
+export async function createTier(tierData, options = {}) {
+  const { validateTierData } = await import('./tierService.js');
+  validateTierData(tierData);
+
+  try {
+    return await handleApiRequest('tiers', 'add', tierData, options);
+  } catch (error) {
+    if (error instanceof GhostAPIError && error.ghostStatusCode === 422) {
+      throw new ValidationError('Tier creation failed due to validation errors', [
+        { field: 'tier', message: error.originalError },
+      ]);
+    }
+    throw error;
+  }
+}
+
+/**
+ * Update an existing tier
+ * @param {string} id - Tier ID
+ * @param {Object} updateData - Tier update data
+ * @param {Object} [options={}] - Options for the API request
+ * @returns {Promise<Object>} Updated tier
+ */
+export async function updateTier(id, updateData, options = {}) {
+  if (!id || typeof id !== 'string' || id.trim().length === 0) {
+    throw new ValidationError('Tier ID is required for update');
+  }
+
+  const { validateTierUpdateData } = await import('./tierService.js');
+  validateTierUpdateData(updateData);
+
+  try {
+    // Get existing tier for merge
+    const existingTier = await handleApiRequest('tiers', 'read', { id }, { id });
+
+    // Merge updates with existing data
+    const mergedData = {
+      ...existingTier,
+      ...updateData,
+      updated_at: existingTier.updated_at,
+    };
+
+    return await handleApiRequest('tiers', 'edit', mergedData, { id, ...options });
+  } catch (error) {
+    if (error instanceof GhostAPIError && error.ghostStatusCode === 404) {
+      throw new NotFoundError('Tier', id);
+    }
+    throw error;
+  }
+}
+
+/**
+ * Delete a tier
+ * @param {string} id - Tier ID
+ * @returns {Promise<Object>} Deletion result
+ */
+export async function deleteTier(id) {
+  if (!id || typeof id !== 'string' || id.trim().length === 0) {
+    throw new ValidationError('Tier ID is required for deletion');
+  }
+
+  try {
+    return await handleApiRequest('tiers', 'delete', { id });
+  } catch (error) {
+    if (error instanceof GhostAPIError && error.ghostStatusCode === 404) {
+      throw new NotFoundError('Tier', id);
+    }
+    throw error;
+  }
+}
+
+/**
+ * Get all tiers with optional filtering
+ * @param {Object} [options={}] - Query options
+ * @param {number} [options.limit] - Number of tiers to return (1-100, default 15)
+ * @param {number} [options.page] - Page number
+ * @param {string} [options.filter] - NQL filter string (e.g., "type:paid", "type:free")
+ * @param {string} [options.order] - Order string
+ * @param {string} [options.include] - Include string
+ * @returns {Promise<Array>} Array of tiers
+ */
+export async function getTiers(options = {}) {
+  const { validateTierQueryOptions } = await import('./tierService.js');
+  validateTierQueryOptions(options);
+
+  const defaultOptions = {
+    limit: 15,
+    ...options,
+  };
+
+  try {
+    const tiers = await handleApiRequest('tiers', 'browse', {}, defaultOptions);
+    return tiers || [];
+  } catch (error) {
+    console.error('Failed to get tiers:', error);
+    throw error;
+  }
+}
+
+/**
+ * Get a single tier by ID
+ * @param {string} id - Tier ID
+ * @returns {Promise<Object>} Tier object
+ */
+export async function getTier(id) {
+  if (!id || typeof id !== 'string' || id.trim().length === 0) {
+    throw new ValidationError('Tier ID is required and must be a non-empty string');
+  }
+
+  try {
+    return await handleApiRequest('tiers', 'read', { id }, { id });
+  } catch (error) {
+    if (error instanceof GhostAPIError && error.ghostStatusCode === 404) {
+      throw new NotFoundError('Tier', id);
+    }
+    throw error;
+  }
+}
+
 /**
  * Health check for Ghost API connection
  */
@@ -1027,10 +1257,18 @@ export default {
   createMember,
   updateMember,
   deleteMember,
+  getMembers,
+  getMember,
+  searchMembers,
   getNewsletters,
   getNewsletter,
   createNewsletter,
   updateNewsletter,
   deleteNewsletter,
+  createTier,
+  updateTier,
+  deleteTier,
+  getTiers,
+  getTier,
   checkHealth,
 };