@jgardner04/ghost-mcp-server 1.1.12 → 1.2.0

package/src/controllers/__tests__/postController.test.js

@@ -0,0 +1,236 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { mockDotenv } from '../../__tests__/helpers/testUtils.js';
+import { createMockContextLogger } from '../../__tests__/helpers/mockLogger.js';
+import {
+  createMockRequest,
+  createMockResponse,
+  createMockNext,
+} from '../../__tests__/helpers/mockExpress.js';
+
+// Mock dotenv
+vi.mock('dotenv', () => mockDotenv());
+
+// Mock logger
+vi.mock('../../utils/logger.js', () => ({
+  createContextLogger: createMockContextLogger(),
+}));
+
+// Mock postService functions
+vi.mock('../../services/postService.js', () => ({
+  createPostService: vi.fn(),
+}));
+
+// Import after mocks are set up
+import { createPost } from '../postController.js';
+import * as postService from '../../services/postService.js';
+
+describe('postController', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('createPost', () => {
+    it('should return 201 with new post on success', async () => {
+      const mockPost = {
+        id: '1',
+        title: 'Test Post',
+        html: '<p>Test content</p>',
+        status: 'draft',
+      };
+      postService.createPostService.mockResolvedValue(mockPost);
+
+      const req = createMockRequest({
+        body: {
+          title: 'Test Post',
+          html: '<p>Test content</p>',
+        },
+      });
+      const res = createMockResponse();
+      const next = createMockNext();
+
+      await createPost(req, res, next);
+
+      expect(postService.createPostService).toHaveBeenCalledWith({
+        title: 'Test Post',
+        html: '<p>Test content</p>',
+      });
+      expect(res.status).toHaveBeenCalledWith(201);
+      expect(res.json).toHaveBeenCalledWith(mockPost);
+      expect(next).not.toHaveBeenCalled();
+    });
+
+    it('should pass through all post fields including feature_image', async () => {
+      const mockPost = {
+        id: '1',
+        title: 'Post with Image',
+        html: '<p>Content</p>',
+        feature_image: 'https://example.com/image.jpg',
+        status: 'published',
+      };
+      postService.createPostService.mockResolvedValue(mockPost);
+
+      const req = createMockRequest({
+        body: {
+          title: 'Post with Image',
+          html: '<p>Content</p>',
+          feature_image: 'https://example.com/image.jpg',
+          status: 'published',
+        },
+      });
+      const res = createMockResponse();
+      const next = createMockNext();
+
+      await createPost(req, res, next);
+
+      expect(postService.createPostService).toHaveBeenCalledWith({
+        title: 'Post with Image',
+        html: '<p>Content</p>',
+        feature_image: 'https://example.com/image.jpg',
+        status: 'published',
+      });
+      expect(res.status).toHaveBeenCalledWith(201);
+      expect(res.json).toHaveBeenCalledWith(mockPost);
+    });
+
+    it('should handle posts with tags', async () => {
+      const mockPost = {
+        id: '1',
+        title: 'Tagged Post',
+        html: '<p>Content</p>',
+        tags: [{ name: 'Technology' }, { name: 'Science' }],
+        status: 'draft',
+      };
+      postService.createPostService.mockResolvedValue(mockPost);
+
+      const req = createMockRequest({
+        body: {
+          title: 'Tagged Post',
+          html: '<p>Content</p>',
+          tags: [{ name: 'Technology' }, { name: 'Science' }],
+        },
+      });
+      const res = createMockResponse();
+      const next = createMockNext();
+
+      await createPost(req, res, next);
+
+      expect(postService.createPostService).toHaveBeenCalledWith({
+        title: 'Tagged Post',
+        html: '<p>Content</p>',
+        tags: [{ name: 'Technology' }, { name: 'Science' }],
+      });
+      expect(res.status).toHaveBeenCalledWith(201);
+      expect(res.json).toHaveBeenCalledWith(mockPost);
+    });
+
+    it('should handle posts with metadata', async () => {
+      const mockPost = {
+        id: '1',
+        title: 'Post with Metadata',
+        html: '<p>Content</p>',
+        meta_title: 'SEO Title',
+        meta_description: 'SEO Description',
+        status: 'draft',
+      };
+      postService.createPostService.mockResolvedValue(mockPost);
+
+      const req = createMockRequest({
+        body: {
+          title: 'Post with Metadata',
+          html: '<p>Content</p>',
+          meta_title: 'SEO Title',
+          meta_description: 'SEO Description',
+        },
+      });
+      const res = createMockResponse();
+      const next = createMockNext();
+
+      await createPost(req, res, next);
+
+      expect(postService.createPostService).toHaveBeenCalledWith({
+        title: 'Post with Metadata',
+        html: '<p>Content</p>',
+        meta_title: 'SEO Title',
+        meta_description: 'SEO Description',
+      });
+      expect(res.status).toHaveBeenCalledWith(201);
+    });
+
+    it('should call next() with error when service throws error', async () => {
+      const mockError = new Error('Failed to create post');
+      postService.createPostService.mockRejectedValue(mockError);
+
+      const req = createMockRequest({
+        body: {
+          title: 'Test Post',
+          html: '<p>Test content</p>',
+        },
+      });
+      const res = createMockResponse();
+      const next = createMockNext();
+
+      await createPost(req, res, next);
+
+      expect(postService.createPostService).toHaveBeenCalledWith({
+        title: 'Test Post',
+        html: '<p>Test content</p>',
+      });
+      expect(res.status).not.toHaveBeenCalled();
+      expect(res.json).not.toHaveBeenCalled();
+      expect(next).toHaveBeenCalledWith(mockError);
+    });
+
+    it('should handle validation errors from service', async () => {
+      const validationError = new Error('Validation failed: title is required');
+      validationError.name = 'ValidationError';
+      postService.createPostService.mockRejectedValue(validationError);
+
+      const req = createMockRequest({
+        body: {
+          html: '<p>Content without title</p>',
+        },
+      });
+      const res = createMockResponse();
+      const next = createMockNext();
+
+      await createPost(req, res, next);
+
+      expect(next).toHaveBeenCalledWith(validationError);
+      expect(res.status).not.toHaveBeenCalled();
+    });
+
+    it('should handle scheduled posts', async () => {
+      const scheduledDate = '2025-12-31T00:00:00Z';
+      const mockPost = {
+        id: '1',
+        title: 'Scheduled Post',
+        html: '<p>Future content</p>',
+        status: 'scheduled',
+        published_at: scheduledDate,
+      };
+      postService.createPostService.mockResolvedValue(mockPost);
+
+      const req = createMockRequest({
+        body: {
+          title: 'Scheduled Post',
+          html: '<p>Future content</p>',
+          status: 'scheduled',
+          published_at: scheduledDate,
+        },
+      });
+      const res = createMockResponse();
+      const next = createMockNext();
+
+      await createPost(req, res, next);
+
+      expect(postService.createPostService).toHaveBeenCalledWith({
+        title: 'Scheduled Post',
+        html: '<p>Future content</p>',
+        status: 'scheduled',
+        published_at: scheduledDate,
+      });
+      expect(res.status).toHaveBeenCalledWith(201);
+      expect(res.json).toHaveBeenCalledWith(mockPost);
+    });
+  });
+});

package/src/controllers/__tests__/tagController.test.js

@@ -0,0 +1,222 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { mockDotenv } from '../../__tests__/helpers/testUtils.js';
+import { createMockContextLogger } from '../../__tests__/helpers/mockLogger.js';
+import {
+  createMockRequest,
+  createMockResponse,
+  createMockNext,
+} from '../../__tests__/helpers/mockExpress.js';
+
+// Mock dotenv
+vi.mock('dotenv', () => mockDotenv());
+
+// Mock logger
+vi.mock('../../utils/logger.js', () => ({
+  createContextLogger: createMockContextLogger(),
+}));
+
+// Mock ghostService functions
+vi.mock('../../services/ghostService.js', () => ({
+  getTags: vi.fn(),
+  createTag: vi.fn(),
+}));
+
+// Import after mocks are set up
+import { getTags, createTag } from '../tagController.js';
+import * as ghostService from '../../services/ghostService.js';
+
+describe('tagController', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('getTags', () => {
+    it('should return 200 with tags array on success', async () => {
+      const mockTags = [
+        { id: '1', name: 'Technology', slug: 'technology' },
+        { id: '2', name: 'Science', slug: 'science' },
+      ];
+      ghostService.getTags.mockResolvedValue(mockTags);
+
+      const req = createMockRequest();
+      const res = createMockResponse();
+      const next = createMockNext();
+
+      await getTags(req, res, next);
+
+      expect(ghostService.getTags).toHaveBeenCalledWith(undefined);
+      expect(res.status).toHaveBeenCalledWith(200);
+      expect(res.json).toHaveBeenCalledWith(mockTags);
+      expect(next).not.toHaveBeenCalled();
+    });
+
+    it('should filter tags by name when name query parameter is provided', async () => {
+      const mockTags = [{ id: '1', name: 'Technology', slug: 'technology' }];
+      ghostService.getTags.mockResolvedValue(mockTags);
+
+      const req = createMockRequest({ query: { name: 'Technology' } });
+      const res = createMockResponse();
+      const next = createMockNext();
+
+      await getTags(req, res, next);
+
+      expect(ghostService.getTags).toHaveBeenCalledWith('Technology');
+      expect(res.status).toHaveBeenCalledWith(200);
+      expect(res.json).toHaveBeenCalledWith(mockTags);
+      expect(next).not.toHaveBeenCalled();
+    });
+
+    it('should call next() with error when service throws error', async () => {
+      const mockError = new Error('Failed to fetch tags');
+      ghostService.getTags.mockRejectedValue(mockError);
+
+      const req = createMockRequest();
+      const res = createMockResponse();
+      const next = createMockNext();
+
+      await getTags(req, res, next);
+
+      expect(ghostService.getTags).toHaveBeenCalledWith(undefined);
+      expect(res.status).not.toHaveBeenCalled();
+      expect(res.json).not.toHaveBeenCalled();
+      expect(next).toHaveBeenCalledWith(mockError);
+    });
+  });
+
+  describe('createTag', () => {
+    it('should return 201 with new tag on success', async () => {
+      const mockTag = { id: '1', name: 'New Tag', slug: 'new-tag' };
+      ghostService.createTag.mockResolvedValue(mockTag);
+
+      const req = createMockRequest({
+        body: {
+          name: 'New Tag',
+          description: 'A new tag description',
+        },
+      });
+      const res = createMockResponse();
+      const next = createMockNext();
+
+      await createTag(req, res, next);
+
+      expect(ghostService.createTag).toHaveBeenCalledWith({
+        name: 'New Tag',
+        description: 'A new tag description',
+        slug: undefined,
+      });
+      expect(res.status).toHaveBeenCalledWith(201);
+      expect(res.json).toHaveBeenCalledWith(mockTag);
+      expect(next).not.toHaveBeenCalled();
+    });
+
+    it('should return 400 when name is missing', async () => {
+      const req = createMockRequest({
+        body: {
+          description: 'A tag without a name',
+        },
+      });
+      const res = createMockResponse();
+      const next = createMockNext();
+
+      await createTag(req, res, next);
+
+      expect(ghostService.createTag).not.toHaveBeenCalled();
+      expect(res.status).toHaveBeenCalledWith(400);
+      expect(res.json).toHaveBeenCalledWith({ message: 'Tag name is required.' });
+      expect(next).not.toHaveBeenCalled();
+    });
+
+    it('should return 400 when name is empty string', async () => {
+      const req = createMockRequest({
+        body: {
+          name: '',
+          description: 'A tag with empty name',
+        },
+      });
+      const res = createMockResponse();
+      const next = createMockNext();
+
+      await createTag(req, res, next);
+
+      expect(ghostService.createTag).not.toHaveBeenCalled();
+      expect(res.status).toHaveBeenCalledWith(400);
+      expect(res.json).toHaveBeenCalledWith({ message: 'Tag name is required.' });
+      expect(next).not.toHaveBeenCalled();
+    });
+
+    it('should call next() with error when service throws error', async () => {
+      const mockError = new Error('Failed to create tag');
+      ghostService.createTag.mockRejectedValue(mockError);
+
+      const req = createMockRequest({
+        body: {
+          name: 'Test Tag',
+        },
+      });
+      const res = createMockResponse();
+      const next = createMockNext();
+
+      await createTag(req, res, next);
+
+      expect(ghostService.createTag).toHaveBeenCalledWith({
+        name: 'Test Tag',
+        description: undefined,
+        slug: undefined,
+      });
+      expect(res.status).not.toHaveBeenCalled();
+      expect(res.json).not.toHaveBeenCalled();
+      expect(next).toHaveBeenCalledWith(mockError);
+    });
+
+    it('should include slug when provided', async () => {
+      const mockTag = { id: '1', name: 'Custom Tag', slug: 'custom-slug' };
+      ghostService.createTag.mockResolvedValue(mockTag);
+
+      const req = createMockRequest({
+        body: {
+          name: 'Custom Tag',
+          slug: 'custom-slug',
+          description: 'A tag with custom slug',
+        },
+      });
+      const res = createMockResponse();
+      const next = createMockNext();
+
+      await createTag(req, res, next);
+
+      expect(ghostService.createTag).toHaveBeenCalledWith({
+        name: 'Custom Tag',
+        slug: 'custom-slug',
+        description: 'A tag with custom slug',
+      });
+      expect(res.status).toHaveBeenCalledWith(201);
+      expect(res.json).toHaveBeenCalledWith(mockTag);
+    });
+
+    it('should pass through additional fields', async () => {
+      const mockTag = { id: '1', name: 'Tag', slug: 'tag', visibility: 'public' };
+      ghostService.createTag.mockResolvedValue(mockTag);
+
+      const req = createMockRequest({
+        body: {
+          name: 'Tag',
+          visibility: 'public',
+          meta_title: 'Custom Meta Title',
+        },
+      });
+      const res = createMockResponse();
+      const next = createMockNext();
+
+      await createTag(req, res, next);
+
+      expect(ghostService.createTag).toHaveBeenCalledWith({
+        name: 'Tag',
+        description: undefined,
+        slug: undefined,
+        visibility: 'public',
+        meta_title: 'Custom Meta Title',
+      });
+      expect(res.status).toHaveBeenCalledWith(201);
+    });
+  });
+});

package/src/mcp_server_improved.js

@@ -272,6 +272,110 @@ server.tool(
   }
 );
 
+// Get Posts Tool
+server.tool(
+  'ghost_get_posts',
+  'Retrieves a list of posts from Ghost CMS with pagination, filtering, and sorting options.',
+  {
+    limit: z
+      .number()
+      .min(1)
+      .max(100)
+      .optional()
+      .describe('Number of posts to retrieve (1-100). Default is 15.'),
+    page: z.number().min(1).optional().describe('Page number for pagination. Default is 1.'),
+    status: z
+      .enum(['published', 'draft', 'scheduled', 'all'])
+      .optional()
+      .describe('Filter posts by status. Options: published, draft, scheduled, all.'),
+    include: z
+      .string()
+      .optional()
+      .describe('Comma-separated list of relations to include (e.g., "tags,authors").'),
+    filter: z
+      .string()
+      .optional()
+      .describe('Ghost NQL filter string for advanced filtering (e.g., "featured:true").'),
+    order: z
+      .string()
+      .optional()
+      .describe('Sort order for results (e.g., "published_at DESC", "title ASC").'),
+  },
+  async (input) => {
+    console.error(`Executing tool: ghost_get_posts`);
+    try {
+      await loadServices();
+
+      // Build options object with provided parameters
+      const options = {};
+      if (input.limit !== undefined) options.limit = input.limit;
+      if (input.page !== undefined) options.page = input.page;
+      if (input.status !== undefined) options.status = input.status;
+      if (input.include !== undefined) options.include = input.include;
+      if (input.filter !== undefined) options.filter = input.filter;
+      if (input.order !== undefined) options.order = input.order;
+
+      const posts = await ghostService.getPosts(options);
+      console.error(`Retrieved ${posts.length} posts from Ghost.`);
+
+      return {
+        content: [{ type: 'text', text: JSON.stringify(posts, null, 2) }],
+      };
+    } catch (error) {
+      console.error(`Error in ghost_get_posts:`, error);
+      return {
+        content: [{ type: 'text', text: `Error retrieving posts: ${error.message}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
+// Get Post Tool
+server.tool(
+  'ghost_get_post',
+  'Retrieves a single post from Ghost CMS by ID or slug.',
+  {
+    id: z.string().optional().describe('The ID of the post to retrieve.'),
+    slug: z.string().optional().describe('The slug of the post to retrieve.'),
+    include: z
+      .string()
+      .optional()
+      .describe('Comma-separated list of relations to include (e.g., "tags,authors").'),
+  },
+  async (input) => {
+    console.error(`Executing tool: ghost_get_post`);
+    try {
+      // Validate that at least one of id or slug is provided
+      if (!input.id && !input.slug) {
+        throw new Error('Either id or slug is required to retrieve a post');
+      }
+
+      await loadServices();
+
+      // Build options object
+      const options = {};
+      if (input.include !== undefined) options.include = input.include;
+
+      // Determine identifier (prefer ID over slug)
+      const identifier = input.id || `slug/${input.slug}`;
+
+      const post = await ghostService.getPost(identifier, options);
+      console.error(`Retrieved post: ${post.title} (ID: ${post.id})`);
+
+      return {
+        content: [{ type: 'text', text: JSON.stringify(post, null, 2) }],
+      };
+    } catch (error) {
+      console.error(`Error in ghost_get_post:`, error);
+      return {
+        content: [{ type: 'text', text: `Error retrieving post: ${error.message}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
 // --- Main Entry Point ---
 
 async function main() {
@@ -282,7 +386,7 @@ async function main() {
 
   console.error('Ghost MCP Server running on stdio transport');
   console.error(
-    'Available tools: ghost_get_tags, ghost_create_tag, ghost_upload_image, ghost_create_post'
+    'Available tools: ghost_get_tags, ghost_create_tag, ghost_upload_image, ghost_create_post, ghost_get_posts, ghost_get_post'
   );
 }