@jgardner04/ghost-mcp-server 1.13.2 → 1.13.4

package/src/schemas/postSchemas.js

@@ -35,7 +35,7 @@ import {
  */
 export const createPostSchema = z.object({
   title: titleSchema,
-  html: htmlContentSchema.describe('HTML content of the post'),
+  html: htmlContentSchema.meta({ description: 'HTML content of the post' }),
   slug: slugSchema.optional(),
   status: postStatusSchema.default('draft'),
   visibility: visibilitySchema.default('public'),
@@ -57,17 +57,21 @@ export const createPostSchema = z.object({
     .max(500, 'Twitter description cannot exceed 500 characters')
     .optional(),
   canonical_url: canonicalUrlSchema,
-  tags: tagsSchema.describe(
-    'Array of tag names or IDs to associate with the post. On update, this fully replaces the existing tags array (not merged).'
-  ),
-  authors: authorsSchema.describe(
-    'Array of author IDs or emails. On update, this fully replaces the existing authors array (not merged).'
-  ),
-  published_at: isoDateSchema.optional().describe('Scheduled publish time (ISO 8601 format)'),
+  tags: tagsSchema.meta({
+    description:
+      'Array of tag names or IDs to associate with the post. On update, this fully replaces the existing tags array (not merged).',
+  }),
+  authors: authorsSchema.meta({
+    description:
+      'Array of author IDs or emails. On update, this fully replaces the existing authors array (not merged).',
+  }),
+  published_at: isoDateSchema
+    .optional()
+    .meta({ description: 'Scheduled publish time (ISO 8601 format)' }),
   codeinjection_head: z.string().optional(),
   codeinjection_foot: z.string().optional(),
-  custom_template: z.string().optional().describe('Custom template filename'),
-  email_only: z.boolean().default(false).describe('Whether post is email-only'),
+  custom_template: z.string().optional().meta({ description: 'Custom template filename' }),
+  email_only: z.boolean().default(false).meta({ description: 'Whether post is email-only' }),
 });
 
 /**
@@ -86,17 +90,20 @@ export const postQuerySchema = z.object({
     .string()
     .regex(/^[a-zA-Z0-9_\-:.'"\s,[\]<>=!+]+$/, 'Invalid filter: contains disallowed characters')
     .optional()
-    .describe('NQL filter string (e.g., "status:published+featured:true")'),
+    .meta({ description: 'NQL filter string (e.g., "status:published+featured:true")' }),
   include: z
     .string()
     .optional()
-    .describe('Comma-separated list of relations (e.g., "tags,authors")'),
-  fields: z.string().optional().describe('Comma-separated list of fields to return'),
+    .meta({ description: 'Comma-separated list of relations (e.g., "tags,authors")' }),
+  fields: z.string().optional().meta({ description: 'Comma-separated list of fields to return' }),
   formats: z
     .string()
     .optional()
-    .describe('Comma-separated list of formats (html, plaintext, mobiledoc)'),
-  order: z.string().optional().describe('Order results (e.g., "published_at DESC", "title ASC")'),
+    .meta({ description: 'Comma-separated list of formats (html, plaintext, mobiledoc)' }),
+  order: z
+    .string()
+    .optional()
+    .meta({ description: 'Order results (e.g., "published_at DESC", "title ASC")' }),
 });
 
 /**

package/src/schemas/tagSchemas.js

@@ -68,9 +68,11 @@ export const tagQueryBaseSchema = z.object({
       'Tag name contains invalid characters. Only letters, numbers, spaces, hyphens, underscores, and apostrophes are allowed'
     )
     .optional()
-    .describe('Filter by exact tag name (legacy parameter, converted to filter internally)'),
-  slug: z.string().optional().describe('Filter by tag slug'),
-  visibility: visibilitySchema.optional().describe('Filter by visibility'),
+    .meta({
+      description: 'Filter by exact tag name (legacy parameter, converted to filter internally)',
+    }),
+  slug: z.string().optional().meta({ description: 'Filter by tag slug' }),
+  visibility: visibilitySchema.optional().meta({ description: 'Filter by visibility' }),
   limit: z
     .union([
       z.number().int().min(1).max(100),
@@ -79,7 +81,7 @@ export const tagQueryBaseSchema = z.object({
     ])
     .default(15)
     .optional()
-    .describe('Number of tags to return (1-100) or "all" for all tags'),
+    .meta({ description: 'Number of tags to return (1-100) or "all" for all tags' }),
   page: z
     .union([z.number().int().min(1), z.string().regex(/^\d+$/).transform(Number)])
     .default(1)
@@ -88,12 +90,15 @@ export const tagQueryBaseSchema = z.object({
     .string()
     .regex(/^[a-zA-Z0-9_\-:.'"\s,[\]<>=!+]+$/, 'Invalid filter: contains disallowed characters')
     .optional()
-    .describe('NQL filter string'),
+    .meta({ description: 'NQL filter string' }),
   include: z
     .string()
     .optional()
-    .describe('Comma-separated list of relations to include (e.g., "count.posts")'),
-  order: z.string().optional().describe('Order results (e.g., "name ASC", "created_at DESC")'),
+    .meta({ description: 'Comma-separated list of relations to include (e.g., "count.posts")' }),
+  order: z
+    .string()
+    .optional()
+    .meta({ description: 'Order results (e.g., "name ASC", "created_at DESC")' }),
 });
 
 /**

package/src/schemas/tierSchemas.js

@@ -47,16 +47,19 @@ export const createTierSchema = z.object({
   name: z.string().min(1, 'Name cannot be empty').max(191, 'Name cannot exceed 191 characters'),
   description: z.string().max(2000, 'Description cannot exceed 2000 characters').optional(),
   slug: slugSchema.optional(),
-  active: z.boolean().default(true).describe('Whether tier is currently active/available'),
+  active: z
+    .boolean()
+    .default(true)
+    .meta({ description: 'Whether tier is currently active/available' }),
   type: z
     .enum(['free', 'paid'], {
-      errorMap: () => ({ message: 'Type must be free or paid' }),
+      error: () => ({ message: 'Type must be free or paid' }),
     })
     .default('paid'),
   welcome_page_url: z.string().url('Invalid welcome page URL').optional(),
   visibility: z
     .enum(['public', 'none'], {
-      errorMap: () => ({ message: 'Visibility must be public or none' }),
+      error: () => ({ message: 'Visibility must be public or none' }),
     })
     .default('public'),
   trial_days: z
@@ -64,7 +67,7 @@ export const createTierSchema = z.object({
     .int()
     .min(0, 'Trial days must be non-negative')
     .default(0)
-    .describe('Number of trial days for paid tiers'),
+    .meta({ description: 'Number of trial days for paid tiers' }),
   currency: z
     .string()
     .length(3, 'Currency must be 3-letter ISO code')
@@ -72,7 +75,10 @@ export const createTierSchema = z.object({
     .optional(),
   monthly_price: z.number().int().min(0, 'Monthly price must be non-negative').optional(),
   yearly_price: z.number().int().min(0, 'Yearly price must be non-negative').optional(),
-  benefits: z.array(z.string()).optional().describe('Array of benefit names/descriptions'),
+  benefits: z
+    .array(z.string())
+    .optional()
+    .meta({ description: 'Array of benefit names/descriptions' }),
 });
 
 /**
@@ -91,12 +97,15 @@ export const tierQuerySchema = z.object({
     .string()
     .regex(/^[a-zA-Z0-9_\-:.'"\s,[\]<>=!+]+$/, 'Invalid filter: contains disallowed characters')
     .optional()
-    .describe('NQL filter string (e.g., "type:paid+active:true")'),
-  include: z.string().optional().describe('Comma-separated list of relations to include'),
+    .meta({ description: 'NQL filter string (e.g., "type:paid+active:true")' }),
+  include: z
+    .string()
+    .optional()
+    .meta({ description: 'Comma-separated list of relations to include' }),
   order: z
     .string()
     .optional()
-    .describe('Order results (e.g., "monthly_price ASC", "created_at DESC")'),
+    .meta({ description: 'Order results (e.g., "monthly_price ASC", "created_at DESC")' }),
 });
 
 /**

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

@@ -1,48 +1,10 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { createMockContextLogger } from '../../__tests__/helpers/mockLogger.js';
 import { mockDotenv } from '../../__tests__/helpers/testUtils.js';
+import { mockGhostApiModule } from '../../__tests__/helpers/mockGhostApi.js';
 
-// Mock the Ghost Admin API with members 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(),
-      },
-      site: {
-        read: vi.fn(),
-      },
-      images: {
-        upload: vi.fn(),
-      },
-    };
-  }),
-}));
+// Mock the Ghost Admin API using shared mock factory
+vi.mock('@tryghost/admin-api', () => mockGhostApiModule());
 
 // Mock dotenv
 vi.mock('dotenv', () => mockDotenv());
@@ -69,6 +31,7 @@ import {
   searchMembers,
   api,
 } from '../ghostServiceImproved.js';
+import { GhostAPIError, NotFoundError } from '../../errors/index.js';
 
 describe('ghostServiceImproved - Members', () => {
   beforeEach(() => {
@@ -173,8 +136,13 @@ describe('ghostServiceImproved - Members', () => {
       expect(api.members.read).toHaveBeenCalledWith(expect.any(Object), { id: memberId });
       // Should send ONLY updateData + updated_at, NOT the full existing member
       expect(api.members.edit).toHaveBeenCalledWith(
-        { name: 'Jane Doe', note: 'Updated note', updated_at: '2023-01-01T00:00:00.000Z' },
-        expect.objectContaining({ id: memberId })
+        {
+          id: memberId,
+          name: 'Jane Doe',
+          note: 'Updated note',
+          updated_at: '2023-01-01T00:00:00.000Z',
+        },
+        {}
       );
       // Verify read-only fields are NOT sent
       const editCallData = api.members.edit.mock.calls[0][0];
@@ -209,21 +177,20 @@ describe('ghostServiceImproved - Members', () => {
     });
 
     it('should throw validation error for missing member ID', async () => {
-      await expect(updateMember(null, { name: 'Test' })).rejects.toThrow(
-        'Member ID is required for update'
-      );
+      await expect(updateMember(null, { name: 'Test' })).rejects.toThrow('Member ID is required');
     });
 
     // NOTE: Input validation tests (invalid email in update) have been moved to
     // MCP layer tests. The service layer now relies on Zod schema validation.
 
     it('should throw not found error if member does not exist', async () => {
-      api.members.read.mockRejectedValue({
-        response: { status: 404 },
-        message: 'Member not found',
-      });
+      const error404 = new GhostAPIError('members.read', 'Member not found', 404);
+      error404.response = { status: 404 };
+      api.members.read.mockRejectedValue(error404);
 
-      await expect(updateMember('non-existent', { name: 'Test' })).rejects.toThrow();
+      const rejection = updateMember('non-existent', { name: 'Test' });
+      await expect(rejection).rejects.toBeInstanceOf(NotFoundError);
+      await expect(rejection).rejects.toThrow('Member not found');
     });
   });
 
@@ -240,16 +207,17 @@ describe('ghostServiceImproved - Members', () => {
     });
 
     it('should throw validation error for missing member ID', async () => {
-      await expect(deleteMember(null)).rejects.toThrow('Member ID is required for deletion');
+      await expect(deleteMember(null)).rejects.toThrow('Member ID is required');
     });
 
     it('should throw not found error if member does not exist', async () => {
-      api.members.delete.mockRejectedValue({
-        response: { status: 404 },
-        message: 'Member not found',
-      });
+      const error404 = new GhostAPIError('members.delete', 'Member not found', 404);
+      error404.response = { status: 404 };
+      api.members.delete.mockRejectedValue(error404);
 
-      await expect(deleteMember('non-existent')).rejects.toThrow();
+      const rejection = deleteMember('non-existent');
+      await expect(rejection).rejects.toBeInstanceOf(NotFoundError);
+      await expect(rejection).rejects.toThrow('Member not found');
     });
   });
 
@@ -391,12 +359,13 @@ describe('ghostServiceImproved - Members', () => {
     // moved to MCP layer tests. The service layer now relies on Zod schema validation.
 
     it('should throw not found error when member not found by ID', async () => {
-      api.members.read.mockRejectedValue({
-        response: { status: 404 },
-        message: 'Member not found',
-      });
+      const error404 = new GhostAPIError('members.read', 'Member not found', 404);
+      error404.response = { status: 404 };
+      api.members.read.mockRejectedValue(error404);
 
-      await expect(getMember({ id: 'non-existent' })).rejects.toThrow();
+      const rejection = getMember({ id: 'non-existent' });
+      await expect(rejection).rejects.toBeInstanceOf(NotFoundError);
+      await expect(rejection).rejects.toThrow('Member not found');
     });
 
     it('should throw not found error when member not found by email', async () => {

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

@@ -1,30 +1,25 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createMockContextLogger } from '../../__tests__/helpers/mockLogger.js';
 import { mockDotenv } from '../../__tests__/helpers/testUtils.js';
+import { mockGhostApiModule } from '../../__tests__/helpers/mockGhostApi.js';
 
-// Mock dotenv before other imports
+// Mock the Ghost Admin API using shared mock factory
+vi.mock('@tryghost/admin-api', () => mockGhostApiModule());
+
+// Mock dotenv
 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,
-  };
-});
+// Mock logger
+vi.mock('../../utils/logger.js', () => ({
+  createContextLogger: createMockContextLogger(),
+}));
+
+// Mock fs for validateImagePath
+vi.mock('fs/promises', () => ({
+  default: {
+    access: vi.fn(),
+  },
+}));
 
 // Import after mocks are set up
 import {
@@ -33,12 +28,10 @@ import {
   createNewsletter,
   updateNewsletter,
   deleteNewsletter,
+  api,
 } 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();
@@ -50,37 +43,37 @@ describe('ghostServiceImproved - Newsletter Operations', () => {
         { id: '1', name: 'Newsletter 1', slug: 'newsletter-1' },
         { id: '2', name: 'Newsletter 2', slug: 'newsletter-2' },
       ];
-      mockNewslettersApi.browse.mockResolvedValue(mockNewsletters);
+      api.newsletters.browse.mockResolvedValue(mockNewsletters);
 
       const result = await getNewsletters();
 
       expect(result).toEqual(mockNewsletters);
-      expect(mockNewslettersApi.browse).toHaveBeenCalledWith({ limit: 'all' }, {});
+      expect(api.newsletters.browse).toHaveBeenCalledWith({ limit: 'all' }, {});
     });
 
     it('should support custom limit', async () => {
       const mockNewsletters = [{ id: '1', name: 'Newsletter 1' }];
-      mockNewslettersApi.browse.mockResolvedValue(mockNewsletters);
+      api.newsletters.browse.mockResolvedValue(mockNewsletters);
 
       await getNewsletters({ limit: 5 });
 
-      expect(mockNewslettersApi.browse).toHaveBeenCalledWith({ limit: 5 }, {});
+      expect(api.newsletters.browse).toHaveBeenCalledWith({ limit: 5 }, {});
     });
 
     it('should support filter option', async () => {
       const mockNewsletters = [{ id: '1', name: 'Active Newsletter' }];
-      mockNewslettersApi.browse.mockResolvedValue(mockNewsletters);
+      api.newsletters.browse.mockResolvedValue(mockNewsletters);
 
       await getNewsletters({ filter: 'status:active' });
 
-      expect(mockNewslettersApi.browse).toHaveBeenCalledWith(
+      expect(api.newsletters.browse).toHaveBeenCalledWith(
         { limit: 'all', filter: 'status:active' },
         {}
       );
     });
 
     it('should handle empty results', async () => {
-      mockNewslettersApi.browse.mockResolvedValue([]);
+      api.newsletters.browse.mockResolvedValue([]);
 
       const result = await getNewsletters();
 
@@ -88,7 +81,7 @@ describe('ghostServiceImproved - Newsletter Operations', () => {
     });
 
     it('should propagate API errors', async () => {
-      mockNewslettersApi.browse.mockRejectedValue(new Error('API Error'));
+      api.newsletters.browse.mockRejectedValue(new Error('API Error'));
 
       await expect(getNewsletters()).rejects.toThrow();
     });
@@ -97,24 +90,24 @@ describe('ghostServiceImproved - Newsletter Operations', () => {
   describe('getNewsletter', () => {
     it('should retrieve a newsletter by ID', async () => {
       const mockNewsletter = { id: 'newsletter-123', name: 'My Newsletter' };
-      mockNewslettersApi.read.mockResolvedValue(mockNewsletter);
+      api.newsletters.read.mockResolvedValue(mockNewsletter);
 
       const result = await getNewsletter('newsletter-123');
 
       expect(result).toEqual(mockNewsletter);
-      expect(mockNewslettersApi.read).toHaveBeenCalledWith({}, { id: 'newsletter-123' });
+      expect(api.newsletters.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();
+      expect(api.newsletters.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);
+      api.newsletters.read.mockRejectedValue(ghostError);
 
       await expect(getNewsletter('nonexistent')).rejects.toThrow(NotFoundError);
     });
@@ -127,12 +120,12 @@ describe('ghostServiceImproved - Newsletter Operations', () => {
         description: 'Our weekly updates',
       };
       const createdNewsletter = { id: '1', ...newsletterData };
-      mockNewslettersApi.add.mockResolvedValue(createdNewsletter);
+      api.newsletters.add.mockResolvedValue(createdNewsletter);
 
       const result = await createNewsletter(newsletterData);
 
       expect(result).toEqual(createdNewsletter);
-      expect(mockNewslettersApi.add).toHaveBeenCalledWith(newsletterData, {});
+      expect(api.newsletters.add).toHaveBeenCalledWith(newsletterData, {});
     });
 
     it('should create newsletter with sender email', async () => {
@@ -143,12 +136,12 @@ describe('ghostServiceImproved - Newsletter Operations', () => {
         sender_reply_to: 'newsletter',
       };
       const createdNewsletter = { id: '1', ...newsletterData };
-      mockNewslettersApi.add.mockResolvedValue(createdNewsletter);
+      api.newsletters.add.mockResolvedValue(createdNewsletter);
 
       const result = await createNewsletter(newsletterData);
 
       expect(result).toEqual(createdNewsletter);
-      expect(mockNewslettersApi.add).toHaveBeenCalledWith(newsletterData, {});
+      expect(api.newsletters.add).toHaveBeenCalledWith(newsletterData, {});
     });
 
     it('should create newsletter with display options', async () => {
@@ -159,12 +152,12 @@ describe('ghostServiceImproved - Newsletter Operations', () => {
         show_header_title: false,
       };
       const createdNewsletter = { id: '1', ...newsletterData };
-      mockNewslettersApi.add.mockResolvedValue(createdNewsletter);
+      api.newsletters.add.mockResolvedValue(createdNewsletter);
 
       const result = await createNewsletter(newsletterData);
 
       expect(result).toEqual(createdNewsletter);
-      expect(mockNewslettersApi.add).toHaveBeenCalledWith(newsletterData, {});
+      expect(api.newsletters.add).toHaveBeenCalledWith(newsletterData, {});
     });
 
     it('should throw ValidationError if name is missing', async () => {
@@ -172,7 +165,7 @@ describe('ghostServiceImproved - Newsletter Operations', () => {
 
       await expect(createNewsletter(invalidData)).rejects.toThrow(ValidationError);
       await expect(createNewsletter(invalidData)).rejects.toThrow('Newsletter validation failed');
-      expect(mockNewslettersApi.add).not.toHaveBeenCalled();
+      expect(api.newsletters.add).not.toHaveBeenCalled();
     });
 
     it('should throw ValidationError if name is empty', async () => {
@@ -180,14 +173,14 @@ describe('ghostServiceImproved - Newsletter Operations', () => {
 
       await expect(createNewsletter(invalidData)).rejects.toThrow(ValidationError);
       await expect(createNewsletter(invalidData)).rejects.toThrow('Newsletter validation failed');
-      expect(mockNewslettersApi.add).not.toHaveBeenCalled();
+      expect(api.newsletters.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);
+      api.newsletters.add.mockRejectedValue(ghostError);
 
       await expect(createNewsletter(newsletterData)).rejects.toThrow();
     });
@@ -205,20 +198,20 @@ describe('ghostServiceImproved - Newsletter Operations', () => {
       const updateData = { name: 'New Name' };
       const updatedNewsletter = { ...existingNewsletter, ...updateData };
 
-      mockNewslettersApi.read.mockResolvedValue(existingNewsletter);
-      mockNewslettersApi.edit.mockResolvedValue(updatedNewsletter);
+      api.newsletters.read.mockResolvedValue(existingNewsletter);
+      api.newsletters.edit.mockResolvedValue(updatedNewsletter);
 
       const result = await updateNewsletter('newsletter-123', updateData);
 
       expect(result).toEqual(updatedNewsletter);
-      expect(mockNewslettersApi.read).toHaveBeenCalledWith({}, { id: 'newsletter-123' });
+      expect(api.newsletters.read).toHaveBeenCalledWith({}, { id: 'newsletter-123' });
       // Should send ONLY updateData + updated_at, NOT the full existing newsletter
-      expect(mockNewslettersApi.edit).toHaveBeenCalledWith(
-        { name: 'New Name', updated_at: '2024-01-01T00:00:00.000Z' },
-        { id: 'newsletter-123' }
+      expect(api.newsletters.edit).toHaveBeenCalledWith(
+        { id: 'newsletter-123', name: 'New Name', updated_at: '2024-01-01T00:00:00.000Z' },
+        {}
       );
       // Verify read-only fields are NOT sent
-      const editCallData = mockNewslettersApi.edit.mock.calls[0][0];
+      const editCallData = api.newsletters.edit.mock.calls[0][0];
       expect(editCallData).not.toHaveProperty('uuid');
       expect(editCallData).not.toHaveProperty('slug');
     });
@@ -235,28 +228,28 @@ describe('ghostServiceImproved - Newsletter Operations', () => {
         subscribe_on_signup: false,
       };
 
-      mockNewslettersApi.read.mockResolvedValue(existingNewsletter);
-      mockNewslettersApi.edit.mockResolvedValue({ ...existingNewsletter, ...updateData });
+      api.newsletters.read.mockResolvedValue(existingNewsletter);
+      api.newsletters.edit.mockResolvedValue({ ...existingNewsletter, ...updateData });
 
       await updateNewsletter('newsletter-123', updateData);
 
       // Should send ONLY updateData + updated_at
-      expect(mockNewslettersApi.edit).toHaveBeenCalledWith(
-        { ...updateData, updated_at: '2024-01-01T00:00:00.000Z' },
-        { id: 'newsletter-123' }
+      expect(api.newsletters.edit).toHaveBeenCalledWith(
+        { id: 'newsletter-123', ...updateData, updated_at: '2024-01-01T00:00:00.000Z' },
+        {}
       );
     });
 
     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();
+      expect(api.newsletters.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);
+      api.newsletters.read.mockRejectedValue(ghostError);
 
       await expect(updateNewsletter('nonexistent', { name: 'New Name' })).rejects.toThrow(
         NotFoundError
@@ -271,39 +264,43 @@ describe('ghostServiceImproved - Newsletter Operations', () => {
       };
       const updateData = { description: 'Updated description' };
 
-      mockNewslettersApi.read.mockResolvedValue(existingNewsletter);
-      mockNewslettersApi.edit.mockResolvedValue({ ...existingNewsletter, ...updateData });
+      api.newsletters.read.mockResolvedValue(existingNewsletter);
+      api.newsletters.edit.mockResolvedValue({ ...existingNewsletter, ...updateData });
 
       await updateNewsletter('newsletter-123', updateData);
 
       // Should send ONLY updateData + updated_at
-      expect(mockNewslettersApi.edit).toHaveBeenCalledWith(
-        { description: 'Updated description', updated_at: '2024-01-01T00:00:00.000Z' },
-        { id: 'newsletter-123' }
+      expect(api.newsletters.edit).toHaveBeenCalledWith(
+        {
+          id: 'newsletter-123',
+          description: 'Updated description',
+          updated_at: '2024-01-01T00:00:00.000Z',
+        },
+        {}
       );
     });
   });
 
   describe('deleteNewsletter', () => {
     it('should delete a newsletter successfully', async () => {
-      mockNewslettersApi.delete.mockResolvedValue({ id: 'newsletter-123' });
+      api.newsletters.delete.mockResolvedValue({ id: 'newsletter-123' });
 
       const result = await deleteNewsletter('newsletter-123');
 
       expect(result).toEqual({ id: 'newsletter-123' });
-      expect(mockNewslettersApi.delete).toHaveBeenCalledWith('newsletter-123', {});
+      expect(api.newsletters.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();
+      expect(api.newsletters.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);
+      api.newsletters.delete.mockRejectedValue(ghostError);
 
       await expect(deleteNewsletter('nonexistent')).rejects.toThrow(NotFoundError);
     });