@jgardner04/ghost-mcp-server 1.5.0 → 1.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jgardner04/ghost-mcp-server",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "A Model Context Protocol (MCP) server for interacting with Ghost CMS via the Admin API",
   "author": "Jonathan Gardner",
   "type": "module",

package/src/mcp_server_improved.js

@@ -780,6 +780,198 @@ server.tool(
   }
 );
 
+// =============================================================================
+// NEWSLETTER TOOLS
+// =============================================================================
+
+// Get Newsletters Tool
+server.tool(
+  'ghost_get_newsletters',
+  'Retrieves a list of newsletters from Ghost CMS with optional filtering.',
+  {
+    limit: z
+      .number()
+      .min(1)
+      .max(100)
+      .optional()
+      .describe('Number of newsletters to retrieve (1-100). Default is all.'),
+    filter: z.string().optional().describe('Ghost NQL filter string for advanced filtering.'),
+  },
+  async (input) => {
+    console.error(`Executing tool: ghost_get_newsletters`);
+    try {
+      await loadServices();
+
+      const options = {};
+      if (input.limit !== undefined) options.limit = input.limit;
+      if (input.filter !== undefined) options.filter = input.filter;
+
+      const ghostServiceImproved = await import('./services/ghostServiceImproved.js');
+      const newsletters = await ghostServiceImproved.getNewsletters(options);
+      console.error(`Retrieved ${newsletters.length} newsletters from Ghost.`);
+
+      return {
+        content: [{ type: 'text', text: JSON.stringify(newsletters, null, 2) }],
+      };
+    } catch (error) {
+      console.error(`Error in ghost_get_newsletters:`, error);
+      return {
+        content: [{ type: 'text', text: `Error retrieving newsletters: ${error.message}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
+// Get Newsletter Tool
+server.tool(
+  'ghost_get_newsletter',
+  'Retrieves a single newsletter from Ghost CMS by ID.',
+  {
+    id: z.string().describe('The ID of the newsletter to retrieve.'),
+  },
+  async ({ id }) => {
+    console.error(`Executing tool: ghost_get_newsletter for ID: ${id}`);
+    try {
+      await loadServices();
+
+      const ghostServiceImproved = await import('./services/ghostServiceImproved.js');
+      const newsletter = await ghostServiceImproved.getNewsletter(id);
+      console.error(`Retrieved newsletter: ${newsletter.name} (ID: ${newsletter.id})`);
+
+      return {
+        content: [{ type: 'text', text: JSON.stringify(newsletter, null, 2) }],
+      };
+    } catch (error) {
+      console.error(`Error in ghost_get_newsletter:`, error);
+      return {
+        content: [{ type: 'text', text: `Error retrieving newsletter: ${error.message}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
+// Create Newsletter Tool
+server.tool(
+  'ghost_create_newsletter',
+  'Creates a new newsletter in Ghost CMS with customizable sender settings and display options.',
+  {
+    name: z.string().describe('The name of the newsletter.'),
+    description: z.string().optional().describe('A description for the newsletter.'),
+    sender_name: z.string().optional().describe('The sender name for newsletter emails.'),
+    sender_email: z
+      .string()
+      .email()
+      .optional()
+      .describe('The sender email address for newsletter emails.'),
+    sender_reply_to: z
+      .enum(['newsletter', 'support'])
+      .optional()
+      .describe('Reply-to address setting. Options: newsletter, support.'),
+    subscribe_on_signup: z
+      .boolean()
+      .optional()
+      .describe('Whether new members are automatically subscribed to this newsletter on signup.'),
+    show_header_icon: z
+      .boolean()
+      .optional()
+      .describe('Whether to show the site icon in the newsletter header.'),
+    show_header_title: z
+      .boolean()
+      .optional()
+      .describe('Whether to show the site title in the newsletter header.'),
+  },
+  async (input) => {
+    console.error(`Executing tool: ghost_create_newsletter with name: ${input.name}`);
+    try {
+      await loadServices();
+
+      const newsletterService = await import('./services/newsletterService.js');
+      const createdNewsletter = await newsletterService.createNewsletterService(input);
+      console.error(`Newsletter created successfully. Newsletter ID: ${createdNewsletter.id}`);
+
+      return {
+        content: [{ type: 'text', text: JSON.stringify(createdNewsletter, null, 2) }],
+      };
+    } catch (error) {
+      console.error(`Error in ghost_create_newsletter:`, error);
+      return {
+        content: [{ type: 'text', text: `Error creating newsletter: ${error.message}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
+// Update Newsletter Tool
+server.tool(
+  'ghost_update_newsletter',
+  'Updates an existing newsletter in Ghost CMS. Can update name, description, sender settings, and display options.',
+  {
+    id: z.string().describe('The ID of the newsletter to update.'),
+    name: z.string().optional().describe('New name for the newsletter.'),
+    description: z.string().optional().describe('New description for the newsletter.'),
+    sender_name: z.string().optional().describe('New sender name for newsletter emails.'),
+    sender_email: z.string().email().optional().describe('New sender email address.'),
+    subscribe_on_signup: z
+      .boolean()
+      .optional()
+      .describe('Whether new members are automatically subscribed to this newsletter on signup.'),
+  },
+  async (input) => {
+    console.error(`Executing tool: ghost_update_newsletter for newsletter ID: ${input.id}`);
+    try {
+      await loadServices();
+
+      const { id, ...updateData } = input;
+
+      const ghostServiceImproved = await import('./services/ghostServiceImproved.js');
+      const updatedNewsletter = await ghostServiceImproved.updateNewsletter(id, updateData);
+      console.error(`Newsletter updated successfully. Newsletter ID: ${updatedNewsletter.id}`);
+
+      return {
+        content: [{ type: 'text', text: JSON.stringify(updatedNewsletter, null, 2) }],
+      };
+    } catch (error) {
+      console.error(`Error in ghost_update_newsletter:`, error);
+      return {
+        content: [{ type: 'text', text: `Error updating newsletter: ${error.message}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
+// Delete Newsletter Tool
+server.tool(
+  'ghost_delete_newsletter',
+  'Deletes a newsletter from Ghost CMS by ID. This operation is permanent and cannot be undone.',
+  {
+    id: z.string().describe('The ID of the newsletter to delete.'),
+  },
+  async ({ id }) => {
+    console.error(`Executing tool: ghost_delete_newsletter for newsletter ID: ${id}`);
+    try {
+      await loadServices();
+
+      const ghostServiceImproved = await import('./services/ghostServiceImproved.js');
+      await ghostServiceImproved.deleteNewsletter(id);
+      console.error(`Newsletter deleted successfully. Newsletter ID: ${id}`);
+
+      return {
+        content: [{ type: 'text', text: `Newsletter ${id} has been successfully deleted.` }],
+      };
+    } catch (error) {
+      console.error(`Error in ghost_delete_newsletter:`, error);
+      return {
+        content: [{ type: 'text', text: `Error deleting newsletter: ${error.message}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
 // --- Main Entry Point ---
 
 async function main() {
@@ -792,7 +984,8 @@ async function main() {
   console.error(
     'Available tools: ghost_get_tags, ghost_create_tag, ghost_upload_image, ' +
       'ghost_create_post, ghost_get_posts, ghost_get_post, ghost_search_posts, ghost_update_post, ghost_delete_post, ' +
-      'ghost_get_pages, ghost_get_page, ghost_create_page, ghost_update_page, ghost_delete_page, ghost_search_pages'
+      'ghost_get_pages, ghost_get_page, ghost_create_page, ghost_update_page, ghost_delete_page, ghost_search_pages, ' +
+      'ghost_get_newsletters, ghost_get_newsletter, ghost_create_newsletter, ghost_update_newsletter, ghost_delete_newsletter'
   );
 }
 

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

@@ -0,0 +1,306 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { mockDotenv } from '../../__tests__/helpers/testUtils.js';
+
+// Mock dotenv before other imports
+vi.mock('dotenv', () => mockDotenv());
+
+// Create a mock Ghost Admin API
+vi.mock('@tryghost/admin-api', () => {
+  const mockNewslettersApi = {
+    browse: vi.fn(),
+    read: vi.fn(),
+    add: vi.fn(),
+    edit: vi.fn(),
+    delete: vi.fn(),
+  };
+
+  return {
+    default: class {
+      constructor() {
+        return {
+          newsletters: mockNewslettersApi,
+        };
+      }
+    },
+    mockNewslettersApi,
+  };
+});
+
+// Import after mocks are set up
+import {
+  getNewsletters,
+  getNewsletter,
+  createNewsletter,
+  updateNewsletter,
+  deleteNewsletter,
+} from '../ghostServiceImproved.js';
+import { ValidationError, NotFoundError } from '../../errors/index.js';
+
+// Get the mock API
+const { mockNewslettersApi } = await vi.importMock('@tryghost/admin-api');
+
+describe('ghostServiceImproved - Newsletter Operations', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('getNewsletters', () => {
+    it('should retrieve all newsletters', async () => {
+      const mockNewsletters = [
+        { id: '1', name: 'Newsletter 1', slug: 'newsletter-1' },
+        { id: '2', name: 'Newsletter 2', slug: 'newsletter-2' },
+      ];
+      mockNewslettersApi.browse.mockResolvedValue(mockNewsletters);
+
+      const result = await getNewsletters();
+
+      expect(result).toEqual(mockNewsletters);
+      expect(mockNewslettersApi.browse).toHaveBeenCalledWith({ limit: 'all' }, {});
+    });
+
+    it('should support custom limit', async () => {
+      const mockNewsletters = [{ id: '1', name: 'Newsletter 1' }];
+      mockNewslettersApi.browse.mockResolvedValue(mockNewsletters);
+
+      await getNewsletters({ limit: 5 });
+
+      expect(mockNewslettersApi.browse).toHaveBeenCalledWith({ limit: 5 }, {});
+    });
+
+    it('should support filter option', async () => {
+      const mockNewsletters = [{ id: '1', name: 'Active Newsletter' }];
+      mockNewslettersApi.browse.mockResolvedValue(mockNewsletters);
+
+      await getNewsletters({ filter: 'status:active' });
+
+      expect(mockNewslettersApi.browse).toHaveBeenCalledWith(
+        { limit: 'all', filter: 'status:active' },
+        {}
+      );
+    });
+
+    it('should handle empty results', async () => {
+      mockNewslettersApi.browse.mockResolvedValue([]);
+
+      const result = await getNewsletters();
+
+      expect(result).toEqual([]);
+    });
+
+    it('should propagate API errors', async () => {
+      mockNewslettersApi.browse.mockRejectedValue(new Error('API Error'));
+
+      await expect(getNewsletters()).rejects.toThrow();
+    });
+  });
+
+  describe('getNewsletter', () => {
+    it('should retrieve a newsletter by ID', async () => {
+      const mockNewsletter = { id: 'newsletter-123', name: 'My Newsletter' };
+      mockNewslettersApi.read.mockResolvedValue(mockNewsletter);
+
+      const result = await getNewsletter('newsletter-123');
+
+      expect(result).toEqual(mockNewsletter);
+      expect(mockNewslettersApi.read).toHaveBeenCalledWith({}, { id: 'newsletter-123' });
+    });
+
+    it('should throw ValidationError if ID is missing', async () => {
+      await expect(getNewsletter()).rejects.toThrow(ValidationError);
+      await expect(getNewsletter()).rejects.toThrow('Newsletter ID is required');
+      expect(mockNewslettersApi.read).not.toHaveBeenCalled();
+    });
+
+    it('should throw NotFoundError when newsletter does not exist', async () => {
+      const ghostError = new Error('Not found');
+      ghostError.response = { status: 404 };
+      mockNewslettersApi.read.mockRejectedValue(ghostError);
+
+      await expect(getNewsletter('nonexistent')).rejects.toThrow(NotFoundError);
+    });
+  });
+
+  describe('createNewsletter', () => {
+    it('should create a newsletter with valid data', async () => {
+      const newsletterData = {
+        name: 'Weekly Newsletter',
+        description: 'Our weekly updates',
+      };
+      const createdNewsletter = { id: '1', ...newsletterData };
+      mockNewslettersApi.add.mockResolvedValue(createdNewsletter);
+
+      const result = await createNewsletter(newsletterData);
+
+      expect(result).toEqual(createdNewsletter);
+      expect(mockNewslettersApi.add).toHaveBeenCalledWith(newsletterData, {});
+    });
+
+    it('should create newsletter with sender email', async () => {
+      const newsletterData = {
+        name: 'Newsletter',
+        sender_name: 'John Doe',
+        sender_email: 'john@example.com',
+        sender_reply_to: 'newsletter',
+      };
+      const createdNewsletter = { id: '1', ...newsletterData };
+      mockNewslettersApi.add.mockResolvedValue(createdNewsletter);
+
+      const result = await createNewsletter(newsletterData);
+
+      expect(result).toEqual(createdNewsletter);
+      expect(mockNewslettersApi.add).toHaveBeenCalledWith(newsletterData, {});
+    });
+
+    it('should create newsletter with display options', async () => {
+      const newsletterData = {
+        name: 'Newsletter',
+        subscribe_on_signup: true,
+        show_header_icon: true,
+        show_header_title: false,
+      };
+      const createdNewsletter = { id: '1', ...newsletterData };
+      mockNewslettersApi.add.mockResolvedValue(createdNewsletter);
+
+      const result = await createNewsletter(newsletterData);
+
+      expect(result).toEqual(createdNewsletter);
+      expect(mockNewslettersApi.add).toHaveBeenCalledWith(newsletterData, {});
+    });
+
+    it('should throw ValidationError if name is missing', async () => {
+      const invalidData = { description: 'No name' };
+
+      await expect(createNewsletter(invalidData)).rejects.toThrow(ValidationError);
+      await expect(createNewsletter(invalidData)).rejects.toThrow('Newsletter validation failed');
+      expect(mockNewslettersApi.add).not.toHaveBeenCalled();
+    });
+
+    it('should throw ValidationError if name is empty', async () => {
+      const invalidData = { name: '' };
+
+      await expect(createNewsletter(invalidData)).rejects.toThrow(ValidationError);
+      await expect(createNewsletter(invalidData)).rejects.toThrow('Newsletter validation failed');
+      expect(mockNewslettersApi.add).not.toHaveBeenCalled();
+    });
+
+    it('should handle Ghost API validation errors', async () => {
+      const newsletterData = { name: 'Newsletter' };
+      const ghostError = new Error('Validation failed');
+      ghostError.response = { status: 422 };
+      mockNewslettersApi.add.mockRejectedValue(ghostError);
+
+      await expect(createNewsletter(newsletterData)).rejects.toThrow();
+    });
+  });
+
+  describe('updateNewsletter', () => {
+    it('should update a newsletter successfully', async () => {
+      const existingNewsletter = {
+        id: 'newsletter-123',
+        name: 'Old Name',
+        updated_at: '2024-01-01T00:00:00.000Z',
+      };
+      const updateData = { name: 'New Name' };
+      const updatedNewsletter = { ...existingNewsletter, ...updateData };
+
+      mockNewslettersApi.read.mockResolvedValue(existingNewsletter);
+      mockNewslettersApi.edit.mockResolvedValue(updatedNewsletter);
+
+      const result = await updateNewsletter('newsletter-123', updateData);
+
+      expect(result).toEqual(updatedNewsletter);
+      expect(mockNewslettersApi.read).toHaveBeenCalledWith({}, { id: 'newsletter-123' });
+      expect(mockNewslettersApi.edit).toHaveBeenCalledWith(
+        {
+          ...existingNewsletter,
+          ...updateData,
+        },
+        { id: 'newsletter-123' }
+      );
+    });
+
+    it('should update newsletter with email settings', async () => {
+      const existingNewsletter = {
+        id: 'newsletter-123',
+        name: 'Newsletter',
+        updated_at: '2024-01-01T00:00:00.000Z',
+      };
+      const updateData = {
+        sender_name: 'Updated Sender',
+        sender_email: 'updated@example.com',
+        subscribe_on_signup: false,
+      };
+
+      mockNewslettersApi.read.mockResolvedValue(existingNewsletter);
+      mockNewslettersApi.edit.mockResolvedValue({ ...existingNewsletter, ...updateData });
+
+      await updateNewsletter('newsletter-123', updateData);
+
+      expect(mockNewslettersApi.edit).toHaveBeenCalledWith(expect.objectContaining(updateData), {
+        id: 'newsletter-123',
+      });
+    });
+
+    it('should throw ValidationError if ID is missing', async () => {
+      await expect(updateNewsletter()).rejects.toThrow(ValidationError);
+      await expect(updateNewsletter()).rejects.toThrow('Newsletter ID is required for update');
+      expect(mockNewslettersApi.read).not.toHaveBeenCalled();
+    });
+
+    it('should throw NotFoundError if newsletter does not exist', async () => {
+      const ghostError = new Error('Not found');
+      ghostError.response = { status: 404 };
+      mockNewslettersApi.read.mockRejectedValue(ghostError);
+
+      await expect(updateNewsletter('nonexistent', { name: 'New Name' })).rejects.toThrow(
+        NotFoundError
+      );
+    });
+
+    it('should preserve updated_at from existing newsletter', async () => {
+      const existingNewsletter = {
+        id: 'newsletter-123',
+        name: 'Newsletter',
+        updated_at: '2024-01-01T00:00:00.000Z',
+      };
+      const updateData = { description: 'Updated description' };
+
+      mockNewslettersApi.read.mockResolvedValue(existingNewsletter);
+      mockNewslettersApi.edit.mockResolvedValue({ ...existingNewsletter, ...updateData });
+
+      await updateNewsletter('newsletter-123', updateData);
+
+      expect(mockNewslettersApi.edit).toHaveBeenCalledWith(
+        expect.objectContaining({
+          updated_at: '2024-01-01T00:00:00.000Z',
+        }),
+        { id: 'newsletter-123' }
+      );
+    });
+  });
+
+  describe('deleteNewsletter', () => {
+    it('should delete a newsletter successfully', async () => {
+      mockNewslettersApi.delete.mockResolvedValue({ id: 'newsletter-123' });
+
+      const result = await deleteNewsletter('newsletter-123');
+
+      expect(result).toEqual({ id: 'newsletter-123' });
+      expect(mockNewslettersApi.delete).toHaveBeenCalledWith('newsletter-123', {});
+    });
+
+    it('should throw ValidationError if ID is missing', async () => {
+      await expect(deleteNewsletter()).rejects.toThrow(ValidationError);
+      await expect(deleteNewsletter()).rejects.toThrow('Newsletter ID is required for deletion');
+      expect(mockNewslettersApi.delete).not.toHaveBeenCalled();
+    });
+
+    it('should throw NotFoundError if newsletter does not exist', async () => {
+      const ghostError = new Error('Not found');
+      ghostError.response = { status: 404 };
+      mockNewslettersApi.delete.mockRejectedValue(ghostError);
+
+      await expect(deleteNewsletter('nonexistent')).rejects.toThrow(NotFoundError);
+    });
+  });
+});

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

@@ -0,0 +1,217 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { mockDotenv } from '../../__tests__/helpers/testUtils.js';
+import { createMockContextLogger } from '../../__tests__/helpers/mockLogger.js';
+
+// Mock dotenv
+vi.mock('dotenv', () => mockDotenv());
+
+// Mock logger
+vi.mock('../../utils/logger.js', () => ({
+  createContextLogger: createMockContextLogger(),
+}));
+
+// Mock ghostServiceImproved functions
+vi.mock('../ghostServiceImproved.js', () => ({
+  createNewsletter: vi.fn(),
+}));
+
+// Import after mocks are set up
+import { createNewsletterService } from '../newsletterService.js';
+import { createNewsletter } from '../ghostServiceImproved.js';
+
+describe('newsletterService', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('createNewsletterService - validation', () => {
+    it('should accept valid input and create a newsletter', async () => {
+      const validInput = {
+        name: 'Weekly Newsletter',
+      };
+      const expectedNewsletter = { id: '1', name: 'Weekly Newsletter', slug: 'weekly-newsletter' };
+      createNewsletter.mockResolvedValue(expectedNewsletter);
+
+      const result = await createNewsletterService(validInput);
+
+      expect(result).toEqual(expectedNewsletter);
+      expect(createNewsletter).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: 'Weekly Newsletter',
+        })
+      );
+    });
+
+    it('should reject input with missing name', async () => {
+      const invalidInput = {};
+
+      await expect(createNewsletterService(invalidInput)).rejects.toThrow(
+        'Invalid newsletter input: "name" is required'
+      );
+      expect(createNewsletter).not.toHaveBeenCalled();
+    });
+
+    it('should accept all optional fields', async () => {
+      const fullInput = {
+        name: 'Monthly Newsletter',
+        description: 'Our monthly updates',
+        sender_name: 'John Doe',
+        sender_email: 'john@example.com',
+        sender_reply_to: 'newsletter',
+        subscribe_on_signup: true,
+        show_header_icon: true,
+        show_header_title: false,
+      };
+      const expectedNewsletter = { id: '1', ...fullInput };
+      createNewsletter.mockResolvedValue(expectedNewsletter);
+
+      const result = await createNewsletterService(fullInput);
+
+      expect(result).toEqual(expectedNewsletter);
+      expect(createNewsletter).toHaveBeenCalledWith(expect.objectContaining(fullInput));
+    });
+
+    it('should validate sender_email is a valid email', async () => {
+      const invalidInput = {
+        name: 'Newsletter',
+        sender_email: 'not-an-email',
+      };
+
+      await expect(createNewsletterService(invalidInput)).rejects.toThrow(
+        'Invalid newsletter input:'
+      );
+      expect(createNewsletter).not.toHaveBeenCalled();
+    });
+
+    it('should accept valid sender_email', async () => {
+      const validInput = {
+        name: 'Newsletter',
+        sender_email: 'valid@example.com',
+      };
+      createNewsletter.mockResolvedValue({ id: '1', name: 'Newsletter' });
+
+      await createNewsletterService(validInput);
+
+      expect(createNewsletter).toHaveBeenCalledWith(
+        expect.objectContaining({
+          sender_email: 'valid@example.com',
+        })
+      );
+    });
+
+    it('should validate sender_reply_to enum values', async () => {
+      const invalidInput = {
+        name: 'Newsletter',
+        sender_reply_to: 'invalid',
+      };
+
+      await expect(createNewsletterService(invalidInput)).rejects.toThrow(
+        'Invalid newsletter input:'
+      );
+      expect(createNewsletter).not.toHaveBeenCalled();
+    });
+
+    it('should accept valid sender_reply_to values', async () => {
+      const validValues = ['newsletter', 'support'];
+      createNewsletter.mockResolvedValue({ id: '1', name: 'Newsletter' });
+
+      for (const value of validValues) {
+        const input = {
+          name: 'Newsletter',
+          sender_reply_to: value,
+        };
+
+        await createNewsletterService(input);
+
+        expect(createNewsletter).toHaveBeenCalledWith(
+          expect.objectContaining({ sender_reply_to: value })
+        );
+        vi.clearAllMocks();
+      }
+    });
+
+    it('should validate subscribe_on_signup is boolean', async () => {
+      const invalidInput = {
+        name: 'Newsletter',
+        subscribe_on_signup: 'yes',
+      };
+
+      await expect(createNewsletterService(invalidInput)).rejects.toThrow(
+        'Invalid newsletter input:'
+      );
+      expect(createNewsletter).not.toHaveBeenCalled();
+    });
+
+    it('should validate show_header_icon is boolean', async () => {
+      const invalidInput = {
+        name: 'Newsletter',
+        show_header_icon: 'true',
+      };
+
+      await expect(createNewsletterService(invalidInput)).rejects.toThrow(
+        'Invalid newsletter input:'
+      );
+      expect(createNewsletter).not.toHaveBeenCalled();
+    });
+
+    it('should validate show_header_title is boolean', async () => {
+      const invalidInput = {
+        name: 'Newsletter',
+        show_header_title: 1,
+      };
+
+      await expect(createNewsletterService(invalidInput)).rejects.toThrow(
+        'Invalid newsletter input:'
+      );
+      expect(createNewsletter).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('createNewsletterService - defaults and transformations', () => {
+    beforeEach(() => {
+      createNewsletter.mockResolvedValue({ id: '1', name: 'Newsletter' });
+    });
+
+    it('should pass through all provided fields', async () => {
+      const input = {
+        name: 'Newsletter',
+        description: 'Test description',
+        sender_name: 'Sender',
+        sender_email: 'sender@example.com',
+        sender_reply_to: 'support',
+        subscribe_on_signup: false,
+        show_header_icon: false,
+        show_header_title: true,
+      };
+
+      await createNewsletterService(input);
+
+      expect(createNewsletter).toHaveBeenCalledWith(expect.objectContaining(input));
+    });
+
+    it('should handle minimal input', async () => {
+      const input = {
+        name: 'Simple Newsletter',
+      };
+
+      await createNewsletterService(input);
+
+      expect(createNewsletter).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: 'Simple Newsletter',
+        })
+      );
+    });
+  });
+
+  describe('createNewsletterService - error handling', () => {
+    it('should propagate errors from ghostServiceImproved', async () => {
+      const input = {
+        name: 'Newsletter',
+      };
+      createNewsletter.mockRejectedValue(new Error('Ghost API error'));
+
+      await expect(createNewsletterService(input)).rejects.toThrow('Ghost API error');
+    });
+  });
+});

package/src/services/ghostServiceImproved.js

@@ -224,6 +224,18 @@ const validators = {
       throw new ValidationError('Page validation failed', errors);
     }
   },
+
+  validateNewsletterData(newsletterData) {
+    const errors = [];
+
+    if (!newsletterData.name || newsletterData.name.trim().length === 0) {
+      errors.push({ field: 'name', message: 'Newsletter name is required' });
+    }
+
+    if (errors.length > 0) {
+      throw new ValidationError('Newsletter validation failed', errors);
+    }
+  },
 };
 
 /**
@@ -739,6 +751,103 @@ export async function deleteTag(tagId) {
   }
 }
 
+/**
+ * Newsletter CRUD Operations
+ */
+
+export async function getNewsletters(options = {}) {
+  const defaultOptions = {
+    limit: 'all',
+    ...options,
+  };
+
+  try {
+    const newsletters = await handleApiRequest('newsletters', 'browse', {}, defaultOptions);
+    return newsletters || [];
+  } catch (error) {
+    console.error('Failed to get newsletters:', error);
+    throw error;
+  }
+}
+
+export async function getNewsletter(newsletterId) {
+  if (!newsletterId) {
+    throw new ValidationError('Newsletter ID is required');
+  }
+
+  try {
+    return await handleApiRequest('newsletters', 'read', { id: newsletterId });
+  } catch (error) {
+    if (error instanceof GhostAPIError && error.ghostStatusCode === 404) {
+      throw new NotFoundError('Newsletter', newsletterId);
+    }
+    throw error;
+  }
+}
+
+export async function createNewsletter(newsletterData) {
+  // Validate input
+  validators.validateNewsletterData(newsletterData);
+
+  try {
+    return await handleApiRequest('newsletters', 'add', newsletterData);
+  } catch (error) {
+    if (error instanceof GhostAPIError && error.ghostStatusCode === 422) {
+      throw new ValidationError('Newsletter creation failed', [
+        { field: 'newsletter', message: error.originalError },
+      ]);
+    }
+    throw error;
+  }
+}
+
+export async function updateNewsletter(newsletterId, updateData) {
+  if (!newsletterId) {
+    throw new ValidationError('Newsletter ID is required for update');
+  }
+
+  try {
+    // Get existing newsletter to retrieve updated_at for conflict resolution
+    const existingNewsletter = await handleApiRequest('newsletters', 'read', {
+      id: newsletterId,
+    });
+
+    // Merge existing data with updates, preserving updated_at
+    const mergedData = {
+      ...existingNewsletter,
+      ...updateData,
+      updated_at: existingNewsletter.updated_at,
+    };
+
+    return await handleApiRequest('newsletters', 'edit', mergedData, { id: newsletterId });
+  } catch (error) {
+    if (error instanceof GhostAPIError && error.ghostStatusCode === 404) {
+      throw new NotFoundError('Newsletter', newsletterId);
+    }
+    if (error instanceof GhostAPIError && error.ghostStatusCode === 422) {
+      throw new ValidationError('Newsletter update failed', [
+        { field: 'newsletter', message: error.originalError },
+      ]);
+    }
+    throw error;
+  }
+}
+
+export async function deleteNewsletter(newsletterId) {
+  if (!newsletterId) {
+    throw new ValidationError('Newsletter ID is required for deletion');
+  }
+
+  try {
+    return await handleApiRequest('newsletters', 'delete', newsletterId);
+  } catch (error) {
+    if (error instanceof GhostAPIError && error.ghostStatusCode === 404) {
+      throw new NotFoundError('Newsletter', newsletterId);
+    }
+    throw error;
+  }
+}
+
 /**
  * Health check for Ghost API connection
  */
@@ -790,5 +899,10 @@ export default {
   getTag,
   updateTag,
   deleteTag,
+  getNewsletters,
+  getNewsletter,
+  createNewsletter,
+  updateNewsletter,
+  deleteNewsletter,
   checkHealth,
 };

package/src/services/newsletterService.js

@@ -0,0 +1,47 @@
+import Joi from 'joi';
+import { createContextLogger } from '../utils/logger.js';
+import { createNewsletter as createGhostNewsletter } from './ghostServiceImproved.js';
+
+/**
+ * Validation schema for newsletter input
+ */
+const newsletterInputSchema = Joi.object({
+  name: Joi.string().required(),
+  description: Joi.string().optional(),
+  sender_name: Joi.string().optional(),
+  sender_email: Joi.string().email().optional(),
+  sender_reply_to: Joi.string().valid('newsletter', 'support').optional(),
+  subscribe_on_signup: Joi.boolean().strict().optional(),
+  show_header_icon: Joi.boolean().strict().optional(),
+  show_header_title: Joi.boolean().strict().optional(),
+});
+
+/**
+ * Service layer function to handle the business logic of creating a newsletter.
+ * Validates input and creates a newsletter in Ghost CMS.
+ * @param {object} newsletterInput - Data received from the controller.
+ * @returns {Promise<object>} The created newsletter object from the Ghost API.
+ */
+const createNewsletterService = async (newsletterInput) => {
+  const logger = createContextLogger('newsletter-service');
+
+  // Validate input
+  const { error, value: validatedInput } = newsletterInputSchema.validate(newsletterInput);
+  if (error) {
+    logger.error('Newsletter input validation failed', {
+      error: error.details[0].message,
+      inputKeys: Object.keys(newsletterInput),
+    });
+    throw new Error(`Invalid newsletter input: ${error.details[0].message}`);
+  }
+
+  logger.info('Creating Ghost newsletter', {
+    name: validatedInput.name,
+    hasSenderEmail: !!validatedInput.sender_email,
+  });
+
+  const newNewsletter = await createGhostNewsletter(validatedInput);
+  return newNewsletter;
+};
+
+export { createNewsletterService };