@jgardner04/ghost-mcp-server 1.13.4 → 1.14.0

package/src/routes/__tests__/imageRoutes.test.js

@@ -41,8 +41,8 @@ vi.mock('../../services/imageProcessingService.js', () => ({
   processImage: vi.fn().mockResolvedValue('/tmp/processed-image.jpg'),
 }));
 
-// Mock the ghost service
-vi.mock('../../services/ghostService.js', () => ({
+// Mock the image upload service (now in images.js, re-exported via ghostServiceImproved.js)
+vi.mock('../../services/images.js', () => ({
   uploadImage: vi.fn().mockResolvedValue({ url: 'https://ghost.com/image.jpg' }),
 }));
 

package/src/schemas/__tests__/common.test.js

@@ -336,12 +336,12 @@ describe('Common Schemas', () => {
   describe('featureImageAltSchema', () => {
     it('should accept valid alt text', () => {
       expect(() => featureImageAltSchema.parse('Image description')).not.toThrow();
-      expect(() => featureImageAltSchema.parse('A'.repeat(125))).not.toThrow();
+      expect(() => featureImageAltSchema.parse('A'.repeat(191))).not.toThrow();
       expect(() => featureImageAltSchema.parse(undefined)).not.toThrow();
     });
 
-    it('should reject too long alt text', () => {
-      expect(() => featureImageAltSchema.parse('A'.repeat(126))).toThrow();
+    it('should reject too long alt text (>191, matches Ghost varchar(191))', () => {
+      expect(() => featureImageAltSchema.parse('A'.repeat(192))).toThrow();
     });
   });
 

package/src/schemas/__tests__/pageSchemas.test.js

@@ -115,16 +115,25 @@ describe('Page Schemas', () => {
       expect(() => createPageSchema.parse(invalidPage)).toThrow();
     });
 
-    it('should reject page with too long feature_image_caption', () => {
+    it('should reject page with too long feature_image_caption (>5000)', () => {
       const invalidPage = {
         title: 'Page',
         html: '<p>Content</p>',
-        feature_image_caption: 'A'.repeat(501),
+        feature_image_caption: 'A'.repeat(5001),
       };
 
       expect(() => createPageSchema.parse(invalidPage)).toThrow();
     });
 
+    it('should accept a 5000-char feature_image_caption', () => {
+      const page = {
+        title: 'Page',
+        html: '<p>Content</p>',
+        feature_image_caption: 'A'.repeat(5000),
+      };
+      expect(() => createPageSchema.parse(page)).not.toThrow();
+    });
+
     it('should reject page with too long og_title', () => {
       const invalidPage = {
         title: 'Page',

package/src/schemas/common.js

@@ -205,11 +205,12 @@ export const featureImageSchema = z.string().url('Invalid feature image URL').op
 
 /**
  * Feature image alt text validation schema
- * Optional alt text for accessibility
+ * Optional alt text for accessibility. Ghost's posts.feature_image_alt
+ * column is varchar(191); anything longer is rejected server-side.
  */
 export const featureImageAltSchema = z
   .string()
-  .max(125, 'Feature image alt text cannot exceed 125 characters')
+  .max(191, 'Feature image alt text cannot exceed 191 characters')
   .optional();
 
 /**

package/src/schemas/pageSchemas.js

@@ -44,7 +44,7 @@ export const createPageSchema = z.object({
   featured: featuredSchema,
   feature_image: featureImageSchema,
   feature_image_alt: featureImageAltSchema,
-  feature_image_caption: z.string().max(500, 'Caption cannot exceed 500 characters').optional(),
+  feature_image_caption: z.string().max(5000, 'Caption cannot exceed 5000 characters').optional(),
   excerpt: excerptSchema,
   custom_excerpt: customExcerptSchema,
   meta_title: metaTitleSchema,

package/src/schemas/postSchemas.js

@@ -42,7 +42,7 @@ export const createPostSchema = z.object({
   featured: featuredSchema,
   feature_image: featureImageSchema,
   feature_image_alt: featureImageAltSchema,
-  feature_image_caption: z.string().max(500, 'Caption cannot exceed 500 characters').optional(),
+  feature_image_caption: z.string().max(5000, 'Caption cannot exceed 5000 characters').optional(),
   excerpt: excerptSchema,
   custom_excerpt: customExcerptSchema,
   meta_title: metaTitleSchema,

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

@@ -0,0 +1,468 @@
+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 using shared mock factory
+vi.mock('@tryghost/admin-api', () => mockGhostApiModule());
+
+// Mock dotenv
+vi.mock('dotenv', () => mockDotenv());
+
+// Mock logger
+vi.mock('../../utils/logger.js', () => ({
+  createContextLogger: createMockContextLogger(),
+}));
+
+// Mock fs for validators
+vi.mock('fs/promises', () => ({
+  default: {
+    access: vi.fn(),
+  },
+}));
+
+import { createResourceService } from '../createResourceService.js';
+import { api, ghostCircuitBreaker } from '../ghostApiClient.js';
+import { GhostAPIError, ValidationError, NotFoundError } from '../../errors/index.js';
+
+describe('createResourceService', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // Reset circuit breaker state between tests so error tests don't trip it open
+    ghostCircuitBreaker.state = 'CLOSED';
+    ghostCircuitBreaker.failureCount = 0;
+    ghostCircuitBreaker.lastFailureTime = null;
+    ghostCircuitBreaker.nextAttempt = null;
+  });
+
+  describe('create', () => {
+    it('should create a resource via handleApiRequest', async () => {
+      const service = createResourceService({
+        resource: 'posts',
+        label: 'Post',
+      });
+
+      const data = { title: 'Test Post', html: '<p>Hello</p>' };
+      const expected = { id: '1', ...data };
+      api.posts.add.mockResolvedValue(expected);
+
+      const result = await service.create(data);
+
+      expect(result).toEqual(expected);
+      expect(api.posts.add).toHaveBeenCalledWith(data, {});
+    });
+
+    it('should merge createDefaults into data', async () => {
+      const service = createResourceService({
+        resource: 'posts',
+        label: 'Post',
+        createDefaults: { status: 'draft' },
+      });
+
+      const data = { title: 'Test Post', html: '<p>Hello</p>' };
+      api.posts.add.mockResolvedValue({ id: '1', ...data, status: 'draft' });
+
+      await service.create(data);
+
+      expect(api.posts.add).toHaveBeenCalledWith(
+        { status: 'draft', title: 'Test Post', html: '<p>Hello</p>' },
+        {}
+      );
+    });
+
+    it('should allow data to override createDefaults', async () => {
+      const service = createResourceService({
+        resource: 'posts',
+        label: 'Post',
+        createDefaults: { status: 'draft' },
+      });
+
+      const data = { title: 'Test', html: '<p>Hi</p>', status: 'published' };
+      api.posts.add.mockResolvedValue({ id: '1', ...data });
+
+      await service.create(data);
+
+      expect(api.posts.add).toHaveBeenCalledWith(
+        expect.objectContaining({ status: 'published' }),
+        {}
+      );
+    });
+
+    it('should pass createOptions to the API call', async () => {
+      const service = createResourceService({
+        resource: 'posts',
+        label: 'Post',
+        createOptions: { source: 'html' },
+      });
+
+      const data = { title: 'Test' };
+      api.posts.add.mockResolvedValue({ id: '1', ...data });
+
+      await service.create(data);
+
+      expect(api.posts.add).toHaveBeenCalledWith(data, { source: 'html' });
+    });
+
+    it('should merge caller options with createOptions', async () => {
+      const service = createResourceService({
+        resource: 'posts',
+        label: 'Post',
+        createOptions: { source: 'html' },
+      });
+
+      const data = { title: 'Test' };
+      api.posts.add.mockResolvedValue({ id: '1', ...data });
+
+      await service.create(data, { formats: 'mobiledoc' });
+
+      expect(api.posts.add).toHaveBeenCalledWith(data, { source: 'html', formats: 'mobiledoc' });
+    });
+
+    it('should call validateCreate before creating', async () => {
+      const validateCreate = vi.fn();
+      const service = createResourceService({
+        resource: 'posts',
+        label: 'Post',
+        validateCreate,
+      });
+
+      const data = { title: 'Test' };
+      api.posts.add.mockResolvedValue({ id: '1', ...data });
+
+      await service.create(data);
+
+      expect(validateCreate).toHaveBeenCalledWith(data);
+      expect(validateCreate).toHaveBeenCalledBefore(api.posts.add);
+    });
+
+    it('should support async validateCreate', async () => {
+      const validateCreate = vi.fn().mockResolvedValue(undefined);
+      const service = createResourceService({
+        resource: 'posts',
+        label: 'Post',
+        validateCreate,
+      });
+
+      const data = { title: 'Test' };
+      api.posts.add.mockResolvedValue({ id: '1', ...data });
+
+      await service.create(data);
+
+      expect(validateCreate).toHaveBeenCalledWith(data);
+      expect(api.posts.add).toHaveBeenCalled();
+    });
+
+    it('should not call API if validateCreate throws', async () => {
+      const validateCreate = vi.fn(() => {
+        throw new ValidationError('Invalid data');
+      });
+      const service = createResourceService({
+        resource: 'posts',
+        label: 'Post',
+        validateCreate,
+      });
+
+      await expect(service.create({ title: '' })).rejects.toThrow(ValidationError);
+      expect(api.posts.add).not.toHaveBeenCalled();
+    });
+
+    it('should convert 422 errors to ValidationError', async () => {
+      const service = createResourceService({
+        resource: 'posts',
+        label: 'Post',
+      });
+
+      const ghostError = new Error('Validation failed');
+      ghostError.response = { status: 422 };
+      api.posts.add.mockRejectedValue(ghostError);
+
+      await expect(service.create({ title: 'Test' })).rejects.toThrow(ValidationError);
+    });
+
+    it('should re-throw non-422 errors', async () => {
+      const service = createResourceService({
+        resource: 'posts',
+        label: 'Post',
+      });
+
+      const error = new Error('Server Error');
+      error.response = { status: 500 };
+      api.posts.add.mockRejectedValue(error);
+
+      await expect(service.create({ title: 'Test' })).rejects.toThrow(GhostAPIError);
+    });
+  });
+
+  describe('update', () => {
+    it('should update a resource with OCC', async () => {
+      const service = createResourceService({
+        resource: 'posts',
+        label: 'Post',
+      });
+
+      const existing = { id: 'post-1', title: 'Old', updated_at: '2024-01-01T00:00:00.000Z' };
+      const updated = { ...existing, title: 'New' };
+
+      api.posts.read.mockResolvedValue(existing);
+      api.posts.edit.mockResolvedValue(updated);
+
+      const result = await service.update('post-1', { title: 'New' });
+
+      expect(result).toEqual(updated);
+      expect(api.posts.read).toHaveBeenCalledWith({}, { id: 'post-1' });
+      expect(api.posts.edit).toHaveBeenCalledWith(
+        { id: 'post-1', title: 'New', updated_at: '2024-01-01T00:00:00.000Z' },
+        {}
+      );
+    });
+
+    it('should throw ValidationError if ID is missing', async () => {
+      const service = createResourceService({
+        resource: 'posts',
+        label: 'Post',
+      });
+
+      await expect(service.update(undefined, { title: 'New' })).rejects.toThrow(ValidationError);
+      await expect(service.update('', { title: 'New' })).rejects.toThrow('Post ID is required');
+    });
+
+    it('should call validateUpdate before updating', async () => {
+      const validateUpdate = vi.fn();
+      const service = createResourceService({
+        resource: 'posts',
+        label: 'Post',
+        validateUpdate,
+      });
+
+      const existing = { id: 'post-1', updated_at: '2024-01-01T00:00:00.000Z' };
+      api.posts.read.mockResolvedValue(existing);
+      api.posts.edit.mockResolvedValue(existing);
+
+      await service.update('post-1', { title: 'New' });
+
+      expect(validateUpdate).toHaveBeenCalledWith('post-1', { title: 'New' });
+    });
+
+    it('should support async validateUpdate', async () => {
+      const validateUpdate = vi.fn().mockResolvedValue(undefined);
+      const service = createResourceService({
+        resource: 'posts',
+        label: 'Post',
+        validateUpdate,
+      });
+
+      const existing = { id: 'post-1', updated_at: '2024-01-01T00:00:00.000Z' };
+      api.posts.read.mockResolvedValue(existing);
+      api.posts.edit.mockResolvedValue(existing);
+
+      await service.update('post-1', { title: 'New' });
+
+      expect(validateUpdate).toHaveBeenCalled();
+    });
+
+    it('should catch 422 on update when catch422OnUpdate is true', async () => {
+      const service = createResourceService({
+        resource: 'newsletters',
+        label: 'Newsletter',
+        catch422OnUpdate: true,
+      });
+
+      const existing = { id: 'nl-1', updated_at: '2024-01-01T00:00:00.000Z' };
+      api.newsletters.read.mockResolvedValue(existing);
+
+      const ghostError = new Error('Name already exists');
+      ghostError.response = { status: 422 };
+      api.newsletters.edit.mockRejectedValue(ghostError);
+
+      try {
+        await service.update('nl-1', { name: 'Dupe' });
+        expect.fail('Expected ValidationError to be thrown');
+      } catch (error) {
+        expect(error).toBeInstanceOf(ValidationError);
+        expect(error.message).toBe('Newsletter update failed');
+      }
+    });
+
+    it('should not catch 422 on update when catch422OnUpdate is false', async () => {
+      const service = createResourceService({
+        resource: 'posts',
+        label: 'Post',
+        catch422OnUpdate: false,
+      });
+
+      const existing = { id: 'post-1', updated_at: '2024-01-01T00:00:00.000Z' };
+      api.posts.read.mockResolvedValue(existing);
+
+      const ghostError = new Error('Something');
+      ghostError.response = { status: 422 };
+      api.posts.edit.mockRejectedValue(ghostError);
+
+      await expect(service.update('post-1', { title: 'New' })).rejects.toThrow(GhostAPIError);
+    });
+  });
+
+  describe('remove', () => {
+    it('should delete a resource by ID', async () => {
+      const service = createResourceService({
+        resource: 'posts',
+        label: 'Post',
+      });
+
+      api.posts.delete.mockResolvedValue({ id: 'post-1' });
+
+      const result = await service.remove('post-1');
+
+      expect(result).toEqual({ id: 'post-1' });
+      expect(api.posts.delete).toHaveBeenCalledWith('post-1', {});
+    });
+
+    it('should throw ValidationError if ID is missing', async () => {
+      const service = createResourceService({
+        resource: 'posts',
+        label: 'Post',
+      });
+
+      await expect(service.remove()).rejects.toThrow(ValidationError);
+      await expect(service.remove()).rejects.toThrow('Post ID is required');
+    });
+
+    it('should throw NotFoundError when resource does not exist', async () => {
+      const service = createResourceService({
+        resource: 'posts',
+        label: 'Post',
+      });
+
+      const ghostError = new Error('Not found');
+      ghostError.response = { status: 404 };
+      api.posts.delete.mockRejectedValue(ghostError);
+
+      await expect(service.remove('nonexistent')).rejects.toThrow(NotFoundError);
+    });
+  });
+
+  describe('getOne', () => {
+    it('should retrieve a resource by ID', async () => {
+      const service = createResourceService({
+        resource: 'posts',
+        label: 'Post',
+      });
+
+      const expected = { id: 'post-1', title: 'Test' };
+      api.posts.read.mockResolvedValue(expected);
+
+      const result = await service.getOne('post-1');
+
+      expect(result).toEqual(expected);
+      expect(api.posts.read).toHaveBeenCalledWith({}, { id: 'post-1' });
+    });
+
+    it('should pass options to read', async () => {
+      const service = createResourceService({
+        resource: 'posts',
+        label: 'Post',
+      });
+
+      api.posts.read.mockResolvedValue({ id: 'post-1' });
+
+      await service.getOne('post-1', { include: 'tags' });
+
+      expect(api.posts.read).toHaveBeenCalledWith({ include: 'tags' }, { id: 'post-1' });
+    });
+
+    it('should throw ValidationError if ID is missing', async () => {
+      const service = createResourceService({
+        resource: 'posts',
+        label: 'Post',
+      });
+
+      await expect(service.getOne()).rejects.toThrow(ValidationError);
+    });
+
+    it('should throw NotFoundError when resource does not exist', async () => {
+      const service = createResourceService({
+        resource: 'posts',
+        label: 'Post',
+      });
+
+      const ghostError = new Error('Not found');
+      ghostError.response = { status: 404 };
+      api.posts.read.mockRejectedValue(ghostError);
+
+      await expect(service.getOne('nonexistent')).rejects.toThrow(NotFoundError);
+    });
+  });
+
+  describe('getList', () => {
+    it('should list resources with defaults', async () => {
+      const service = createResourceService({
+        resource: 'posts',
+        label: 'Post',
+        listDefaults: { limit: 15, include: 'tags,authors' },
+      });
+
+      const expected = [{ id: '1' }, { id: '2' }];
+      api.posts.browse.mockResolvedValue(expected);
+
+      const result = await service.getList();
+
+      expect(result).toEqual(expected);
+      expect(api.posts.browse).toHaveBeenCalledWith({ limit: 15, include: 'tags,authors' }, {});
+    });
+
+    it('should allow overriding defaults', async () => {
+      const service = createResourceService({
+        resource: 'posts',
+        label: 'Post',
+        listDefaults: { limit: 15, include: 'tags,authors' },
+      });
+
+      api.posts.browse.mockResolvedValue([]);
+
+      await service.getList({ limit: 5, filter: 'status:published' });
+
+      expect(api.posts.browse).toHaveBeenCalledWith(
+        { limit: 5, include: 'tags,authors', filter: 'status:published' },
+        {}
+      );
+    });
+
+    it('should return empty array when API returns null/undefined', async () => {
+      const service = createResourceService({
+        resource: 'posts',
+        label: 'Post',
+      });
+
+      api.posts.browse.mockResolvedValue(null);
+
+      const result = await service.getList();
+
+      expect(result).toEqual([]);
+    });
+
+    it('should return empty array when API returns empty array', async () => {
+      const service = createResourceService({
+        resource: 'posts',
+        label: 'Post',
+      });
+
+      api.posts.browse.mockResolvedValue([]);
+
+      const result = await service.getList();
+
+      expect(result).toEqual([]);
+    });
+
+    it('should use default limit of 15 when no listDefaults provided', async () => {
+      const service = createResourceService({
+        resource: 'tags',
+        label: 'Tag',
+      });
+
+      api.tags.browse.mockResolvedValue([]);
+
+      await service.getList();
+
+      expect(api.tags.browse).toHaveBeenCalledWith({ limit: 15 }, {});
+    });
+  });
+});

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

@@ -20,7 +20,6 @@ import {
   createTag,
   getTags,
   getSiteInfo,
-  uploadImage,
   handleApiRequest,
   api,
 } from '../ghostService.js';
@@ -209,24 +208,6 @@ describe('ghostService', () => {
     });
   });
 
-  describe('uploadImage', () => {
-    it('should throw error when image path is missing', async () => {
-      await expect(uploadImage()).rejects.toThrow('Image path is required for upload');
-      await expect(uploadImage('')).rejects.toThrow('Image path is required for upload');
-    });
-
-    it('should successfully upload image with valid path', async () => {
-      const imagePath = '/path/to/image.jpg';
-      const expectedResult = { url: 'https://example.com/uploaded-image.jpg' };
-      api.images.upload.mockResolvedValue(expectedResult);
-
-      const result = await uploadImage(imagePath);
-
-      expect(result).toEqual(expectedResult);
-      expect(api.images.upload).toHaveBeenCalledWith({ file: imagePath });
-    });
-  });
-
   describe('createPost', () => {
     it('should throw error when title is missing', async () => {
       await expect(createPost({})).rejects.toThrow('Post title is required');

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

@@ -185,7 +185,6 @@ describe('ghostServiceImproved - Members', () => {
 
     it('should throw not found error if member does not exist', async () => {
       const error404 = new GhostAPIError('members.read', 'Member not found', 404);
-      error404.response = { status: 404 };
       api.members.read.mockRejectedValue(error404);
 
       const rejection = updateMember('non-existent', { name: 'Test' });
@@ -212,7 +211,6 @@ describe('ghostServiceImproved - Members', () => {
 
     it('should throw not found error if member does not exist', async () => {
       const error404 = new GhostAPIError('members.delete', 'Member not found', 404);
-      error404.response = { status: 404 };
       api.members.delete.mockRejectedValue(error404);
 
       const rejection = deleteMember('non-existent');
@@ -360,7 +358,6 @@ describe('ghostServiceImproved - Members', () => {
 
     it('should throw not found error when member not found by ID', async () => {
       const error404 = new GhostAPIError('members.read', 'Member not found', 404);
-      error404.response = { status: 404 };
       api.members.read.mockRejectedValue(error404);
 
       const rejection = getMember({ id: 'non-existent' });

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

@@ -242,7 +242,7 @@ describe('ghostServiceImproved - Newsletter Operations', () => {
 
     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');
+      await expect(updateNewsletter()).rejects.toThrow('Newsletter ID is required');
       expect(api.newsletters.read).not.toHaveBeenCalled();
     });
 
@@ -293,7 +293,7 @@ describe('ghostServiceImproved - Newsletter Operations', () => {
 
     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');
+      await expect(deleteNewsletter()).rejects.toThrow('Newsletter ID is required');
       expect(api.newsletters.delete).not.toHaveBeenCalled();
     });
 

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

@@ -274,7 +274,6 @@ describe('ghostServiceImproved - Pages', () => {
 
     it('should handle page not found (404)', async () => {
       const error404 = new GhostAPIError('pages.read', 'Page not found', 404);
-      error404.response = { status: 404 };
       api.pages.read.mockRejectedValue(error404);
 
       const rejection = updatePage('nonexistent-id', { title: 'Updated' });
@@ -387,7 +386,6 @@ describe('ghostServiceImproved - Pages', () => {
 
     it('should handle page not found (404)', async () => {
       const error404 = new GhostAPIError('pages.delete', 'Page not found', 404);
-      error404.response = { status: 404 };
       api.pages.delete.mockRejectedValue(error404);
 
       const rejection = deletePage('nonexistent-id');
@@ -437,7 +435,6 @@ describe('ghostServiceImproved - Pages', () => {
 
     it('should handle page not found (404)', async () => {
       const error404 = new GhostAPIError('pages.read', 'Page not found', 404);
-      error404.response = { status: 404 };
       api.pages.read.mockRejectedValue(error404);
 
       const rejection = getPage('nonexistent-id');

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

@@ -93,7 +93,6 @@ describe('ghostServiceImproved - Posts (updatePost)', () => {
 
     it('should handle post not found (404)', async () => {
       const error404 = new GhostAPIError('posts.read', 'Post not found', 404);
-      error404.response = { status: 404 };
       api.posts.read.mockRejectedValue(error404);
 
       const rejection = updatePost('nonexistent-id', { title: 'Updated' });