@jgardner04/ghost-mcp-server 1.7.0 → 1.8.0

package/package.json

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

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

@@ -0,0 +1,275 @@
+import { describe, it, expect } from 'vitest';
+import {
+  emailSchema,
+  urlSchema,
+  isoDateSchema,
+  slugSchema,
+  ghostIdSchema,
+  nqlFilterSchema,
+  limitSchema,
+  pageSchema,
+  postStatusSchema,
+  visibilitySchema,
+  htmlContentSchema,
+  titleSchema,
+  excerptSchema,
+  metaTitleSchema,
+  metaDescriptionSchema,
+  featuredSchema,
+  featureImageSchema,
+  featureImageAltSchema,
+  tagNameSchema,
+} from '../common.js';
+
+describe('Common Schemas', () => {
+  describe('emailSchema', () => {
+    it('should accept valid email addresses', () => {
+      expect(() => emailSchema.parse('test@example.com')).not.toThrow();
+      expect(() => emailSchema.parse('user.name+tag@example.co.uk')).not.toThrow();
+    });
+
+    it('should reject invalid email addresses', () => {
+      expect(() => emailSchema.parse('not-an-email')).toThrow();
+      expect(() => emailSchema.parse('missing@domain')).toThrow();
+      expect(() => emailSchema.parse('@example.com')).toThrow();
+    });
+  });
+
+  describe('urlSchema', () => {
+    it('should accept valid URLs', () => {
+      expect(() => urlSchema.parse('https://example.com')).not.toThrow();
+      expect(() => urlSchema.parse('http://localhost:3000/path')).not.toThrow();
+    });
+
+    it('should reject invalid URLs', () => {
+      expect(() => urlSchema.parse('not-a-url')).toThrow();
+      expect(() => urlSchema.parse('://invalid')).toThrow();
+    });
+  });
+
+  describe('isoDateSchema', () => {
+    it('should accept valid ISO 8601 datetime strings', () => {
+      expect(() => isoDateSchema.parse('2024-01-15T10:30:00Z')).not.toThrow();
+      expect(() => isoDateSchema.parse('2024-01-15T10:30:00.000Z')).not.toThrow();
+    });
+
+    it('should reject invalid datetime strings', () => {
+      expect(() => isoDateSchema.parse('2024-01-15')).toThrow();
+      expect(() => isoDateSchema.parse('not-a-date')).toThrow();
+    });
+  });
+
+  describe('slugSchema', () => {
+    it('should accept valid slugs', () => {
+      expect(() => slugSchema.parse('my-blog-post')).not.toThrow();
+      expect(() => slugSchema.parse('post-123')).not.toThrow();
+      expect(() => slugSchema.parse('simple')).not.toThrow();
+    });
+
+    it('should reject invalid slugs', () => {
+      expect(() => slugSchema.parse('My Post')).toThrow(); // spaces
+      expect(() => slugSchema.parse('post_123')).toThrow(); // underscores
+      expect(() => slugSchema.parse('Post-123')).toThrow(); // uppercase
+      expect(() => slugSchema.parse('post!')).toThrow(); // special chars
+    });
+  });
+
+  describe('ghostIdSchema', () => {
+    it('should accept valid Ghost IDs', () => {
+      expect(() => ghostIdSchema.parse('507f1f77bcf86cd799439011')).not.toThrow();
+      expect(() => ghostIdSchema.parse('abcdef1234567890abcdef12')).not.toThrow();
+    });
+
+    it('should reject invalid Ghost IDs', () => {
+      expect(() => ghostIdSchema.parse('short')).toThrow(); // too short
+      expect(() => ghostIdSchema.parse('507f1f77bcf86cd799439011abc')).toThrow(); // too long
+      expect(() => ghostIdSchema.parse('507f1f77bcf86cd79943901G')).toThrow(); // invalid char
+      expect(() => ghostIdSchema.parse('507F1F77BCF86CD799439011')).toThrow(); // uppercase
+    });
+  });
+
+  describe('nqlFilterSchema', () => {
+    it('should accept valid NQL filter strings', () => {
+      expect(() => nqlFilterSchema.parse('status:published')).not.toThrow();
+      expect(() => nqlFilterSchema.parse('tag:news+featured:true')).not.toThrow();
+      expect(() => nqlFilterSchema.parse("author:'John Doe'")).not.toThrow();
+    });
+
+    it('should reject NQL strings with disallowed characters', () => {
+      expect(() => nqlFilterSchema.parse('status;DROP TABLE')).toThrow();
+      expect(() => nqlFilterSchema.parse('test&invalid')).toThrow();
+    });
+
+    it('should allow undefined/optional', () => {
+      expect(() => nqlFilterSchema.parse(undefined)).not.toThrow();
+    });
+  });
+
+  describe('limitSchema', () => {
+    it('should accept valid limits', () => {
+      expect(limitSchema.parse(1)).toBe(1);
+      expect(limitSchema.parse(50)).toBe(50);
+      expect(limitSchema.parse(100)).toBe(100);
+    });
+
+    it('should reject invalid limits', () => {
+      expect(() => limitSchema.parse(0)).toThrow();
+      expect(() => limitSchema.parse(101)).toThrow();
+      expect(() => limitSchema.parse(-1)).toThrow();
+      expect(() => limitSchema.parse(1.5)).toThrow();
+    });
+
+    it('should use default value', () => {
+      expect(limitSchema.parse(undefined)).toBe(15);
+    });
+  });
+
+  describe('pageSchema', () => {
+    it('should accept valid page numbers', () => {
+      expect(pageSchema.parse(1)).toBe(1);
+      expect(pageSchema.parse(100)).toBe(100);
+    });
+
+    it('should reject invalid page numbers', () => {
+      expect(() => pageSchema.parse(0)).toThrow();
+      expect(() => pageSchema.parse(-1)).toThrow();
+      expect(() => pageSchema.parse(1.5)).toThrow();
+    });
+
+    it('should use default value', () => {
+      expect(pageSchema.parse(undefined)).toBe(1);
+    });
+  });
+
+  describe('postStatusSchema', () => {
+    it('should accept valid statuses', () => {
+      expect(() => postStatusSchema.parse('draft')).not.toThrow();
+      expect(() => postStatusSchema.parse('published')).not.toThrow();
+      expect(() => postStatusSchema.parse('scheduled')).not.toThrow();
+    });
+
+    it('should reject invalid statuses', () => {
+      expect(() => postStatusSchema.parse('invalid')).toThrow();
+      expect(() => postStatusSchema.parse('DRAFT')).toThrow();
+    });
+  });
+
+  describe('visibilitySchema', () => {
+    it('should accept valid visibility values', () => {
+      expect(() => visibilitySchema.parse('public')).not.toThrow();
+      expect(() => visibilitySchema.parse('members')).not.toThrow();
+      expect(() => visibilitySchema.parse('paid')).not.toThrow();
+      expect(() => visibilitySchema.parse('tiers')).not.toThrow();
+    });
+
+    it('should reject invalid visibility values', () => {
+      expect(() => visibilitySchema.parse('private')).toThrow();
+      expect(() => visibilitySchema.parse('PUBLIC')).toThrow();
+    });
+  });
+
+  describe('htmlContentSchema', () => {
+    it('should accept non-empty HTML strings', () => {
+      expect(() => htmlContentSchema.parse('<p>Hello World</p>')).not.toThrow();
+      expect(() => htmlContentSchema.parse('Plain text')).not.toThrow();
+    });
+
+    it('should reject empty strings', () => {
+      expect(() => htmlContentSchema.parse('')).toThrow();
+    });
+  });
+
+  describe('titleSchema', () => {
+    it('should accept valid titles', () => {
+      expect(() => titleSchema.parse('My Blog Post')).not.toThrow();
+      expect(() => titleSchema.parse('A'.repeat(255))).not.toThrow();
+    });
+
+    it('should reject invalid titles', () => {
+      expect(() => titleSchema.parse('')).toThrow();
+      expect(() => titleSchema.parse('A'.repeat(256))).toThrow();
+    });
+  });
+
+  describe('excerptSchema', () => {
+    it('should accept valid excerpts', () => {
+      expect(() => excerptSchema.parse('A short description')).not.toThrow();
+      expect(() => excerptSchema.parse('A'.repeat(500))).not.toThrow();
+      expect(() => excerptSchema.parse(undefined)).not.toThrow();
+    });
+
+    it('should reject too long excerpts', () => {
+      expect(() => excerptSchema.parse('A'.repeat(501))).toThrow();
+    });
+  });
+
+  describe('metaTitleSchema', () => {
+    it('should accept valid meta titles', () => {
+      expect(() => metaTitleSchema.parse('SEO Title')).not.toThrow();
+      expect(() => metaTitleSchema.parse('A'.repeat(300))).not.toThrow();
+      expect(() => metaTitleSchema.parse(undefined)).not.toThrow();
+    });
+
+    it('should reject too long meta titles', () => {
+      expect(() => metaTitleSchema.parse('A'.repeat(301))).toThrow();
+    });
+  });
+
+  describe('metaDescriptionSchema', () => {
+    it('should accept valid meta descriptions', () => {
+      expect(() => metaDescriptionSchema.parse('SEO description')).not.toThrow();
+      expect(() => metaDescriptionSchema.parse('A'.repeat(500))).not.toThrow();
+      expect(() => metaDescriptionSchema.parse(undefined)).not.toThrow();
+    });
+
+    it('should reject too long meta descriptions', () => {
+      expect(() => metaDescriptionSchema.parse('A'.repeat(501))).toThrow();
+    });
+  });
+
+  describe('featuredSchema', () => {
+    it('should accept boolean values', () => {
+      expect(featuredSchema.parse(true)).toBe(true);
+      expect(featuredSchema.parse(false)).toBe(false);
+    });
+
+    it('should use default value', () => {
+      expect(featuredSchema.parse(undefined)).toBe(false);
+    });
+  });
+
+  describe('featureImageSchema', () => {
+    it('should accept valid image URLs', () => {
+      expect(() => featureImageSchema.parse('https://example.com/image.jpg')).not.toThrow();
+      expect(() => featureImageSchema.parse(undefined)).not.toThrow();
+    });
+
+    it('should reject invalid URLs', () => {
+      expect(() => featureImageSchema.parse('not-a-url')).toThrow();
+    });
+  });
+
+  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(undefined)).not.toThrow();
+    });
+
+    it('should reject too long alt text', () => {
+      expect(() => featureImageAltSchema.parse('A'.repeat(126))).toThrow();
+    });
+  });
+
+  describe('tagNameSchema', () => {
+    it('should accept valid tag names', () => {
+      expect(() => tagNameSchema.parse('Technology')).not.toThrow();
+      expect(() => tagNameSchema.parse('A'.repeat(191))).not.toThrow();
+    });
+
+    it('should reject invalid tag names', () => {
+      expect(() => tagNameSchema.parse('')).toThrow();
+      expect(() => tagNameSchema.parse('A'.repeat(192))).toThrow();
+    });
+  });
+});

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

@@ -0,0 +1,194 @@
+import { describe, it, expect } from 'vitest';
+import {
+  createPostSchema,
+  updatePostSchema,
+  postQuerySchema,
+  postIdSchema,
+  postOutputSchema,
+} from '../postSchemas.js';
+
+describe('Post Schemas', () => {
+  describe('createPostSchema', () => {
+    it('should accept valid post creation data', () => {
+      const validPost = {
+        title: 'My Blog Post',
+        html: '<p>This is the content of the post.</p>',
+        status: 'draft',
+      };
+
+      expect(() => createPostSchema.parse(validPost)).not.toThrow();
+    });
+
+    it('should accept minimal post creation data', () => {
+      const minimalPost = {
+        title: 'Title',
+        html: '<p>Content</p>',
+      };
+
+      const result = createPostSchema.parse(minimalPost);
+      expect(result.title).toBe('Title');
+      expect(result.status).toBe('draft'); // default
+      expect(result.visibility).toBe('public'); // default
+      expect(result.featured).toBe(false); // default
+    });
+
+    it('should accept post with all fields', () => {
+      const fullPost = {
+        title: 'Complete Post',
+        html: '<p>Full content</p>',
+        slug: 'complete-post',
+        status: 'published',
+        visibility: 'members',
+        featured: true,
+        feature_image: 'https://example.com/image.jpg',
+        feature_image_alt: 'Image description',
+        feature_image_caption: 'Photo caption',
+        excerpt: 'Brief summary',
+        custom_excerpt: 'Custom summary',
+        meta_title: 'SEO Title',
+        meta_description: 'SEO Description',
+        tags: ['tech', 'news'],
+        authors: ['author@example.com'],
+        published_at: '2024-01-15T10:30:00.000Z',
+        canonical_url: 'https://example.com/original',
+      };
+
+      expect(() => createPostSchema.parse(fullPost)).not.toThrow();
+    });
+
+    it('should reject post without title', () => {
+      const invalidPost = {
+        html: '<p>Content</p>',
+      };
+
+      expect(() => createPostSchema.parse(invalidPost)).toThrow();
+    });
+
+    it('should reject post without html', () => {
+      const invalidPost = {
+        title: 'Title',
+      };
+
+      expect(() => createPostSchema.parse(invalidPost)).toThrow();
+    });
+
+    it('should reject post with invalid status', () => {
+      const invalidPost = {
+        title: 'Title',
+        html: '<p>Content</p>',
+        status: 'invalid',
+      };
+
+      expect(() => createPostSchema.parse(invalidPost)).toThrow();
+    });
+
+    it('should reject post with too long title', () => {
+      const invalidPost = {
+        title: 'A'.repeat(256),
+        html: '<p>Content</p>',
+      };
+
+      expect(() => createPostSchema.parse(invalidPost)).toThrow();
+    });
+  });
+
+  describe('updatePostSchema', () => {
+    it('should accept partial post updates', () => {
+      const update = {
+        title: 'Updated Title',
+      };
+
+      expect(() => updatePostSchema.parse(update)).not.toThrow();
+    });
+
+    it('should accept empty update object', () => {
+      expect(() => updatePostSchema.parse({})).not.toThrow();
+    });
+  });
+
+  describe('postQuerySchema', () => {
+    it('should accept valid query parameters', () => {
+      const query = {
+        limit: 20,
+        page: 2,
+        filter: 'status:published+featured:true',
+      };
+
+      expect(() => postQuerySchema.parse(query)).not.toThrow();
+    });
+
+    it('should accept query with include parameter', () => {
+      const query = {
+        include: 'tags,authors',
+      };
+
+      expect(() => postQuerySchema.parse(query)).not.toThrow();
+    });
+
+    it('should accept empty query object', () => {
+      const result = postQuerySchema.parse({});
+      expect(result).toBeDefined();
+      // Note: optional fields with defaults don't apply when field is omitted
+    });
+  });
+
+  describe('postIdSchema', () => {
+    it('should accept valid Ghost ID', () => {
+      const validId = {
+        id: '507f1f77bcf86cd799439011',
+      };
+
+      expect(() => postIdSchema.parse(validId)).not.toThrow();
+    });
+
+    it('should reject invalid Ghost ID', () => {
+      const invalidId = {
+        id: 'invalid-id',
+      };
+
+      expect(() => postIdSchema.parse(invalidId)).toThrow();
+    });
+  });
+
+  describe('postOutputSchema', () => {
+    it('should accept valid post output from Ghost API', () => {
+      const apiPost = {
+        id: '507f1f77bcf86cd799439011',
+        uuid: '550e8400-e29b-41d4-a716-446655440000',
+        title: 'My Post',
+        slug: 'my-post',
+        html: '<p>Content</p>',
+        comment_id: null,
+        feature_image: 'https://example.com/image.jpg',
+        feature_image_alt: 'Alt text',
+        feature_image_caption: 'Caption',
+        featured: false,
+        status: 'published',
+        visibility: 'public',
+        created_at: '2024-01-15T10:30:00.000Z',
+        updated_at: '2024-01-15T10:30:00.000Z',
+        published_at: '2024-01-15T10:30:00.000Z',
+        custom_excerpt: 'Excerpt',
+        codeinjection_head: null,
+        codeinjection_foot: null,
+        custom_template: null,
+        canonical_url: null,
+        url: 'https://example.com/my-post',
+        excerpt: 'Auto excerpt',
+        reading_time: 5,
+        email_only: false,
+        og_image: null,
+        og_title: null,
+        og_description: null,
+        twitter_image: null,
+        twitter_title: null,
+        twitter_description: null,
+        meta_title: null,
+        meta_description: null,
+        email_subject: null,
+      };
+
+      expect(() => postOutputSchema.parse(apiPost)).not.toThrow();
+    });
+  });
+});