@jgardner04/ghost-mcp-server 1.13.2 → 1.13.3

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

@@ -173,8 +173,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];

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

@@ -214,8 +214,8 @@ describe('ghostServiceImproved - Newsletter Operations', () => {
       expect(mockNewslettersApi.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' }
+        { 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];
@@ -242,8 +242,8 @@ describe('ghostServiceImproved - Newsletter Operations', () => {
 
       // Should send ONLY updateData + updated_at
       expect(mockNewslettersApi.edit).toHaveBeenCalledWith(
-        { ...updateData, updated_at: '2024-01-01T00:00:00.000Z' },
-        { id: 'newsletter-123' }
+        { id: 'newsletter-123', ...updateData, updated_at: '2024-01-01T00:00:00.000Z' },
+        {}
       );
     });
 
@@ -278,8 +278,12 @@ describe('ghostServiceImproved - Newsletter Operations', () => {
 
       // Should send ONLY updateData + updated_at
       expect(mockNewslettersApi.edit).toHaveBeenCalledWith(
-        { description: 'Updated description', updated_at: '2024-01-01T00:00:00.000Z' },
-        { id: 'newsletter-123' }
+        {
+          id: 'newsletter-123',
+          description: 'Updated description',
+          updated_at: '2024-01-01T00:00:00.000Z',
+        },
+        {}
       );
     });
   });

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

@@ -292,8 +292,8 @@ describe('ghostServiceImproved - Pages', () => {
       expect(api.pages.read).toHaveBeenCalledWith({}, { id: pageId });
       // Should send ONLY updateData + updated_at, NOT the full existing page
       expect(api.pages.edit).toHaveBeenCalledWith(
-        { title: 'Updated Title', updated_at: '2024-01-01T00:00:00.000Z' },
-        { id: pageId }
+        { id: pageId, title: 'Updated Title', updated_at: '2024-01-01T00:00:00.000Z' },
+        {}
       );
       // Verify read-only fields are NOT sent
       const editCallData = api.pages.edit.mock.calls[0][0];
@@ -345,8 +345,8 @@ describe('ghostServiceImproved - Pages', () => {
 
   describe('deletePage', () => {
     it('should throw error when page ID is missing', async () => {
-      await expect(deletePage(null)).rejects.toThrow('Page ID is required');
-      await expect(deletePage('')).rejects.toThrow('Page ID is required');
+      await expect(deletePage(null)).rejects.toThrow('Page ID is required for deletion');
+      await expect(deletePage('')).rejects.toThrow('Page ID is required for deletion');
     });
 
     it('should delete page successfully', async () => {

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

@@ -95,8 +95,8 @@ describe('ghostServiceImproved - Posts (updatePost)', () => {
       expect(result).toEqual(expectedResult);
       // Should send ONLY updateData + updated_at, NOT the full existing post
       expect(api.posts.edit).toHaveBeenCalledWith(
-        { title: 'Updated Title', updated_at: '2024-01-01T00:00:00.000Z' },
-        { id: postId }
+        { id: postId, title: 'Updated Title', updated_at: '2024-01-01T00:00:00.000Z' },
+        {}
       );
       // Verify read-only fields are NOT sent
       const editCallData = api.posts.edit.mock.calls[0][0];
@@ -173,8 +173,8 @@ describe('ghostServiceImproved - Posts (updatePost)', () => {
 
       expect(result).toBeDefined();
       expect(api.posts.edit).toHaveBeenCalledWith(
-        { ...updateData, updated_at: existingPost.updated_at },
-        { id: postId }
+        { id: postId, ...updateData, updated_at: existingPost.updated_at },
+        {}
       );
     });
   });

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

@@ -431,8 +431,8 @@ describe('ghostServiceImproved - Tags', () => {
       expect(api.tags.read).toHaveBeenCalled();
       // Should send ONLY updateData, NOT the full existing tag
       expect(api.tags.edit).toHaveBeenCalledWith(
-        { name: 'Updated JavaScript', description: 'Updated description' },
-        { id: tagId }
+        { id: tagId, name: 'Updated JavaScript', description: 'Updated description' },
+        {}
       );
       // Verify read-only fields are NOT sent
       const editCallData = api.tags.edit.mock.calls[0][0];

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

@@ -270,14 +270,7 @@ describe('ghostServiceImproved - Tiers', () => {
 
       const result = await getTier('tier-1');
 
-      expect(api.tiers.read).toHaveBeenCalledWith(
-        expect.objectContaining({
-          id: 'tier-1',
-        }),
-        expect.objectContaining({
-          id: 'tier-1',
-        })
-      );
+      expect(api.tiers.read).toHaveBeenCalledWith({}, { id: 'tier-1' });
       expect(result).toEqual(mockTier);
     });
 
@@ -327,14 +320,16 @@ describe('ghostServiceImproved - Tiers', () => {
 
       const result = await updateTier('tier-1', updateData);
 
-      expect(api.tiers.read).toHaveBeenCalledWith(
-        expect.objectContaining({ id: 'tier-1' }),
-        expect.objectContaining({ id: 'tier-1' })
-      );
+      expect(api.tiers.read).toHaveBeenCalledWith({}, { id: 'tier-1' });
       // Should send ONLY updateData + updated_at, NOT the full existing tier
       expect(api.tiers.edit).toHaveBeenCalledWith(
-        { name: 'Premium Plus', monthly_price: 1299, updated_at: '2024-01-01T00:00:00.000Z' },
-        expect.objectContaining({ id: 'tier-1' })
+        {
+          id: 'tier-1',
+          name: 'Premium Plus',
+          monthly_price: 1299,
+          updated_at: '2024-01-01T00:00:00.000Z',
+        },
+        {}
       );
       // Verify read-only fields are NOT sent
       const editCallData = api.tiers.edit.mock.calls[0][0];

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

@@ -6,7 +6,6 @@ import {
   validateMemberLookup,
   validateSearchQuery,
   validateSearchOptions,
-  sanitizeNqlValue,
 } from '../memberService.js';
 
 describe('memberService - Validation', () => {
@@ -447,31 +446,4 @@ describe('memberService - Validation', () => {
       );
     });
   });
-
-  describe('sanitizeNqlValue', () => {
-    it('should escape backslashes', () => {
-      expect(sanitizeNqlValue('test\\value')).toBe('test\\\\value');
-    });
-
-    it('should escape single quotes', () => {
-      expect(sanitizeNqlValue("test'value")).toBe("test\\'value");
-    });
-
-    it('should escape double quotes', () => {
-      expect(sanitizeNqlValue('test"value')).toBe('test\\"value');
-    });
-
-    it('should handle multiple special characters', () => {
-      expect(sanitizeNqlValue('test\'value"with\\chars')).toBe('test\\\'value\\"with\\\\chars');
-    });
-
-    it('should not modify strings without special characters', () => {
-      expect(sanitizeNqlValue('normalvalue')).toBe('normalvalue');
-      expect(sanitizeNqlValue('test@example.com')).toBe('test@example.com');
-    });
-
-    it('should handle empty string', () => {
-      expect(sanitizeNqlValue('')).toBe('');
-    });
-  });
 });

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

@@ -3,7 +3,6 @@ import {
   validateTierData,
   validateTierUpdateData,
   validateTierQueryOptions,
-  sanitizeNqlValue,
 } from '../tierService.js';
 import { ValidationError } from '../../errors/index.js';
 
@@ -342,31 +341,4 @@ describe('tierService - Validation', () => {
       ).not.toThrow();
     });
   });
-
-  describe('sanitizeNqlValue', () => {
-    it('should return value if undefined or null', () => {
-      expect(sanitizeNqlValue(null)).toBe(null);
-      expect(sanitizeNqlValue(undefined)).toBe(undefined);
-    });
-
-    it('should escape backslashes', () => {
-      expect(sanitizeNqlValue('test\\value')).toBe('test\\\\value');
-    });
-
-    it('should escape single quotes', () => {
-      expect(sanitizeNqlValue("test'value")).toBe("test\\'value");
-    });
-
-    it('should escape double quotes', () => {
-      expect(sanitizeNqlValue('test"value')).toBe('test\\"value');
-    });
-
-    it('should escape multiple special characters', () => {
-      expect(sanitizeNqlValue('test\\value"with\'quotes')).toBe('test\\\\value\\"with\\\'quotes');
-    });
-
-    it('should handle strings without special characters', () => {
-      expect(sanitizeNqlValue('simple-value')).toBe('simple-value');
-    });
-  });
 });