@jgardner04/ghost-mcp-server 1.13.4 → 1.14.0

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

@@ -252,7 +252,6 @@ describe('ghostServiceImproved - Tags', () => {
 
     it('should throw not found error when tag does not exist', async () => {
       const error404 = new GhostAPIError('tags.read', 'Tag not found', 404);
-      error404.response = { status: 404 };
       api.tags.read.mockRejectedValue(error404);
 
       const rejection = getTag('non-existent');
@@ -411,7 +410,6 @@ describe('ghostServiceImproved - Tags', () => {
 
     it('should throw not found error if tag does not exist', async () => {
       const error404 = new GhostAPIError('tags.read', 'Tag not found', 404);
-      error404.response = { status: 404 };
       api.tags.read.mockRejectedValue(error404);
 
       const rejection = updateTag('non-existent', { name: 'Test' });
@@ -438,7 +436,6 @@ describe('ghostServiceImproved - Tags', () => {
 
     it('should throw not found error if tag does not exist', async () => {
       const error404 = new GhostAPIError('tags.delete', 'Tag not found', 404);
-      error404.response = { status: 404 };
       api.tags.delete.mockRejectedValue(error404);
 
       const rejection = deleteTag('non-existent');

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

@@ -295,9 +295,7 @@ describe('ghostServiceImproved - Tiers', () => {
     });
 
     it('should throw ValidationError when ID is missing', async () => {
-      await expect(updateTier('', { name: 'Updated' })).rejects.toThrow(
-        'Tier ID is required for update'
-      );
+      await expect(updateTier('', { name: 'Updated' })).rejects.toThrow('Tier ID is required');
     });
 
     it('should throw ValidationError for invalid update data', async () => {
@@ -327,11 +325,11 @@ describe('ghostServiceImproved - Tiers', () => {
     });
 
     it('should throw ValidationError when ID is missing', async () => {
-      await expect(deleteTier()).rejects.toThrow('Tier ID is required for deletion');
+      await expect(deleteTier()).rejects.toThrow('Tier ID is required');
     });
 
     it('should throw ValidationError when ID is empty string', async () => {
-      await expect(deleteTier('')).rejects.toThrow('Tier ID is required for deletion');
+      await expect(deleteTier('')).rejects.toThrow('Tier ID is required');
     });
 
     it('should throw NotFoundError when tier does not exist', async () => {

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

@@ -1,204 +1,175 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { mockDotenv } from '../../__tests__/helpers/testUtils.js';
-import { createMockContextLogger } from '../../__tests__/helpers/mockLogger.js';
-
-// Mock dotenv
-vi.mock('dotenv', () => mockDotenv());
+import { describe, it, expect, beforeAll, afterAll, vi } from 'vitest';
+import sharp from 'sharp';
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
 
-// Mock logger
+import { createMockContextLogger } from '../../__tests__/helpers/mockLogger.js';
 vi.mock('../../utils/logger.js', () => ({
   createContextLogger: createMockContextLogger(),
 }));
 
-// Mock sharp with chainable API
-const mockMetadata = vi.fn();
-const mockResize = vi.fn();
-const mockJpeg = vi.fn();
-const mockToFile = vi.fn();
-
-const createMockSharp = () => {
-  const instance = {
-    metadata: mockMetadata,
-    resize: mockResize,
-    jpeg: mockJpeg,
-  };
-
-  // Make methods chainable
-  mockResize.mockReturnValue(instance);
-  mockJpeg.mockReturnValue(instance);
-  instance.toFile = mockToFile;
-
-  return instance;
-};
-
-vi.mock('sharp', () => ({
-  default: vi.fn(() => createMockSharp()),
-}));
-
-// Mock fs
-vi.mock('fs', () => ({
-  default: {
-    existsSync: vi.fn(),
-  },
-}));
+// Import under test (real sharp, real filesystem)
+const { processImage } = await import('../imageProcessingService.js');
+
+const tmpRoot = path.join(os.tmpdir(), `ghost-mcp-img-test-${Date.now()}`);
+const fixtures = {};
+
+async function makeRasterFixture(format, width, height = width) {
+  const file = path.join(tmpRoot, `in-${format}-${width}.${format === 'jpeg' ? 'jpg' : format}`);
+  await sharp({
+    create: {
+      width,
+      height,
+      channels: format === 'png' ? 4 : 3,
+      background: { r: 10, g: 50, b: 150, alpha: 1 },
+    },
+  })
+    [format]()
+    .toFile(file);
+  return file;
+}
+
+beforeAll(async () => {
+  await fs.mkdir(tmpRoot, { recursive: true });
+
+  fixtures.pngSmall = await makeRasterFixture('png', 800);
+  fixtures.pngLarge = await makeRasterFixture('png', 2000);
+  fixtures.jpegSmall = await makeRasterFixture('jpeg', 800);
+  fixtures.jpegLarge = await makeRasterFixture('jpeg', 2000);
+  fixtures.webpSmall = await makeRasterFixture('webp', 800);
+  fixtures.webpLarge = await makeRasterFixture('webp', 2000);
+
+  // SVG: write minimal vector source
+  fixtures.svg = path.join(tmpRoot, 'in.svg');
+  await fs.writeFile(
+    fixtures.svg,
+    '<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64"><rect width="64" height="64" fill="#39f"/></svg>'
+  );
+
+  // GIF: sharp cannot reliably create animated GIFs across versions; use a
+  // known-valid 1x1 transparent GIF89a byte sequence for a deterministic fixture.
+  fixtures.gif = path.join(tmpRoot, 'in.gif');
+  await fs.writeFile(
+    fixtures.gif,
+    Buffer.from(
+      '47494638396101000100800000ffffff00000021f90401000001002c00000000010001000002024401003b',
+      'hex'
+    )
+  );
+
+  // ICO: minimal 1x1 ICO header (used only for passthrough byte comparison).
+  fixtures.ico = path.join(tmpRoot, 'in.ico');
+  await fs.writeFile(
+    fixtures.ico,
+    Buffer.from(
+      '00000100010001010000010020003000000016000000280000000100000002000000010020000000000004000000000000000000000000000000000000000000000000000000000000000000000000',
+      'hex'
+    )
+  );
+});
 
-// Mock path - use actual implementation but allow spying
-vi.mock('path', async () => {
-  const actual = await vi.importActual('path');
-  return {
-    default: actual.default,
-    ...actual,
-  };
+afterAll(async () => {
+  await fs.rm(tmpRoot, { recursive: true, force: true });
 });
 
-// Import after mocks are set up
-import { processImage } from '../imageProcessingService.js';
-import sharp from 'sharp';
-import fs from 'fs';
-
-describe('imageProcessingService', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    // Reset mock implementations
-    mockMetadata.mockResolvedValue({ width: 800, size: 100000 });
-    mockToFile.mockResolvedValue();
-    fs.existsSync.mockReturnValue(true);
+async function metaOf(file) {
+  return sharp(file).metadata();
+}
+
+describe('processImage — format passthrough', () => {
+  it('PNG <= 1200: preserves format and passes through unmodified', async () => {
+    const out = await processImage(fixtures.pngSmall, tmpRoot);
+    expect(path.extname(out).toLowerCase()).toBe('.png');
+    const m = await metaOf(out);
+    expect(m.format).toBe('png');
+    expect(m.width).toBe(800);
   });
 
-  describe('Input Validation', () => {
-    it('should accept valid inputPath and outputDir', async () => {
-      const inputPath = '/tmp/test-image.jpg';
-      const outputDir = '/tmp/output';
-
-      await processImage(inputPath, outputDir);
-
-      expect(sharp).toHaveBeenCalledWith(inputPath);
-      expect(mockToFile).toHaveBeenCalled();
-    });
-
-    it('should reject missing inputPath', async () => {
-      await expect(processImage(undefined, '/tmp/output')).rejects.toThrow(
-        'Invalid processing parameters'
-      );
-      expect(sharp).not.toHaveBeenCalled();
-    });
-
-    it('should reject missing outputDir', async () => {
-      await expect(processImage('/tmp/test.jpg', undefined)).rejects.toThrow(
-        'Invalid processing parameters'
-      );
-      expect(sharp).not.toHaveBeenCalled();
-    });
+  it('PNG > 1200: resized but still PNG (no JPEG conversion)', async () => {
+    const out = await processImage(fixtures.pngLarge, tmpRoot);
+    expect(path.extname(out).toLowerCase()).toBe('.png');
+    const m = await metaOf(out);
+    expect(m.format).toBe('png');
+    expect(m.width).toBe(1200);
   });
 
-  describe('Path Security', () => {
-    it('should resolve paths correctly', async () => {
-      const inputPath = './relative/path/image.jpg';
-      const outputDir = './output';
-
-      await processImage(inputPath, outputDir);
-
-      expect(fs.existsSync).toHaveBeenCalledWith(expect.stringContaining('image.jpg'));
-      expect(mockToFile).toHaveBeenCalledWith(expect.stringContaining('output'));
-    });
-
-    it('should throw error when input file does not exist', async () => {
-      fs.existsSync.mockReturnValue(false);
-
-      await expect(processImage('/tmp/nonexistent.jpg', '/tmp/output')).rejects.toThrow(
-        'Input file does not exist'
-      );
-      expect(sharp).not.toHaveBeenCalled();
-    });
+  it('JPEG <= 1200: passes through as JPEG', async () => {
+    const out = await processImage(fixtures.jpegSmall, tmpRoot);
+    expect(path.extname(out).toLowerCase()).toMatch(/\.jpe?g$/);
+    const m = await metaOf(out);
+    expect(m.format).toBe('jpeg');
+    expect(m.width).toBe(800);
   });
 
-  describe('Image Processing', () => {
-    it('should not resize image when width <= MAX_WIDTH (1200)', async () => {
-      mockMetadata.mockResolvedValue({ width: 1000, size: 100000 });
-
-      await processImage('/tmp/small-image.jpg', '/tmp/output');
-
-      expect(mockResize).not.toHaveBeenCalled();
-      expect(mockJpeg).toHaveBeenCalledWith({ quality: 80 });
-      expect(mockToFile).toHaveBeenCalled();
-    });
-
-    it('should resize image when width > MAX_WIDTH (1200)', async () => {
-      mockMetadata.mockResolvedValue({ width: 2000, size: 200000 });
-
-      await processImage('/tmp/large-image.jpg', '/tmp/output');
-
-      expect(mockResize).toHaveBeenCalledWith({ width: 1200 });
-      expect(mockJpeg).toHaveBeenCalledWith({ quality: 80 });
-      expect(mockToFile).toHaveBeenCalled();
-    });
-
-    it('should generate output filename with timestamp and processed prefix', async () => {
-      const inputPath = '/tmp/test-photo.jpg';
-      const outputDir = '/tmp/output';
-
-      // Mock Date.now to get predictable filename
-      const mockTimestamp = 1234567890;
-      vi.spyOn(Date, 'now').mockReturnValue(mockTimestamp);
+  it('JPEG > 1200: resized as JPEG', async () => {
+    const out = await processImage(fixtures.jpegLarge, tmpRoot);
+    const m = await metaOf(out);
+    expect(m.format).toBe('jpeg');
+    expect(m.width).toBe(1200);
+  });
 
-      await processImage(inputPath, outputDir);
+  it('WEBP <= 1200: passes through as WEBP', async () => {
+    const out = await processImage(fixtures.webpSmall, tmpRoot);
+    const m = await metaOf(out);
+    expect(m.format).toBe('webp');
+    expect(m.width).toBe(800);
+  });
 
-      expect(mockToFile).toHaveBeenCalledWith(
-        expect.stringMatching(/processed-1234567890-test-photo\.jpg$/)
-      );
+  it('WEBP > 1200: resized as WEBP', async () => {
+    const out = await processImage(fixtures.webpLarge, tmpRoot);
+    const m = await metaOf(out);
+    expect(m.format).toBe('webp');
+    expect(m.width).toBe(1200);
+  });
 
-      vi.restoreAllMocks();
-    });
+  it('SVG: passthrough — output bytes identical to input (never touched by sharp)', async () => {
+    const out = await processImage(fixtures.svg, tmpRoot);
+    expect(path.extname(out).toLowerCase()).toBe('.svg');
+    const [a, b] = await Promise.all([fs.readFile(fixtures.svg), fs.readFile(out)]);
+    expect(a.equals(b)).toBe(true);
+  });
 
-    it('should convert image to JPEG with quality setting of 80', async () => {
-      await processImage('/tmp/image.png', '/tmp/output');
+  it('GIF: passthrough — output bytes identical to input (animation-safe)', async () => {
+    const out = await processImage(fixtures.gif, tmpRoot);
+    expect(path.extname(out).toLowerCase()).toBe('.gif');
+    const [a, b] = await Promise.all([fs.readFile(fixtures.gif), fs.readFile(out)]);
+    expect(a.equals(b)).toBe(true);
+  });
 
-      expect(mockJpeg).toHaveBeenCalledWith({ quality: 80 });
-      expect(mockToFile).toHaveBeenCalled();
-    });
+  it('ICO: passthrough — output bytes identical to input', async () => {
+    const out = await processImage(fixtures.ico, tmpRoot, { purpose: 'icon' });
+    expect(path.extname(out).toLowerCase()).toBe('.ico');
+    const [a, b] = await Promise.all([fs.readFile(fixtures.ico), fs.readFile(out)]);
+    expect(a.equals(b)).toBe(true);
+  });
 
-    it('should handle images with multiple dots in filename', async () => {
-      const inputPath = '/tmp/my.test.image.png';
-      const outputDir = '/tmp/output';
-      const mockTimestamp = 9999999999;
-      vi.spyOn(Date, 'now').mockReturnValue(mockTimestamp);
+  it('output path is distinct from input path', async () => {
+    const out = await processImage(fixtures.pngSmall, tmpRoot);
+    expect(out).not.toBe(fixtures.pngSmall);
+  });
+});
 
-      await processImage(inputPath, outputDir);
+describe('processImage — validation & errors', () => {
+  it('rejects missing inputPath', async () => {
+    await expect(processImage(undefined, tmpRoot)).rejects.toThrow(/Invalid processing parameters/);
+  });
 
-      expect(mockToFile).toHaveBeenCalledWith(
-        expect.stringMatching(/processed-9999999999-my\.test\.image\.jpg$/)
-      );
+  it('rejects missing outputDir', async () => {
+    await expect(processImage(fixtures.pngSmall, undefined)).rejects.toThrow(
+      /Invalid processing parameters/
+    );
+  });
 
-      vi.restoreAllMocks();
-    });
+  it('throws when input file does not exist', async () => {
+    await expect(processImage('/nonexistent/xyz.png', tmpRoot)).rejects.toThrow(
+      /Input file does not exist/
+    );
   });
 
-  describe('Error Handling', () => {
-    it('should catch and re-throw sharp processing failures', async () => {
-      const processingError = new Error('Sharp processing failed');
-      mockMetadata.mockRejectedValue(processingError);
-
-      await expect(processImage('/tmp/corrupt.jpg', '/tmp/output')).rejects.toThrow(
-        'Image processing failed: Sharp processing failed'
-      );
-    });
-
-    it('should include original error message in re-thrown error', async () => {
-      const originalMessage = 'Input buffer contains unsupported image format';
-      mockToFile.mockRejectedValue(new Error(originalMessage));
-
-      await expect(processImage('/tmp/bad-format.dat', '/tmp/output')).rejects.toThrow(
-        `Image processing failed: ${originalMessage}`
-      );
-    });
-
-    it('should handle errors during JPEG conversion', async () => {
-      const conversionError = new Error('JPEG conversion failed');
-      mockToFile.mockRejectedValue(conversionError);
-
-      await expect(processImage('/tmp/image.jpg', '/tmp/output')).rejects.toThrow(
-        'Image processing failed: JPEG conversion failed'
-      );
-    });
+  it('wraps sharp failures with context', async () => {
+    const bogus = path.join(tmpRoot, 'bogus.png');
+    await fs.writeFile(bogus, 'not an image');
+    await expect(processImage(bogus, tmpRoot)).rejects.toThrow(/Image processing failed/);
   });
 });

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

@@ -0,0 +1,78 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { mockGhostApiModule } from '../../__tests__/helpers/mockGhostApi.js';
+import { createMockContextLogger } from '../../__tests__/helpers/mockLogger.js';
+import { mockDotenv } from '../../__tests__/helpers/testUtils.js';
+
+vi.mock('@tryghost/admin-api', () => mockGhostApiModule());
+vi.mock('dotenv', () => mockDotenv());
+vi.mock('../../utils/logger.js', () => ({
+  createContextLogger: createMockContextLogger(),
+}));
+
+// Stub path validation so these tests focus on argument shaping, not FS.
+vi.mock('../validators.js', () => ({
+  validators: { validateImagePath: vi.fn().mockResolvedValue(undefined) },
+}));
+
+import { uploadImage } from '../images.js';
+import { api } from '../ghostApiClient.js';
+import { ValidationError } from '../../errors/index.js';
+
+describe('images.uploadImage (domain module used by MCP server)', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('forwards purpose and ref to the SDK', async () => {
+    const expected = { url: 'https://cdn/x.png', ref: 'original.png' };
+    api.images.upload.mockResolvedValue(expected);
+
+    const result = await uploadImage('/tmp/x.png', {
+      purpose: 'icon',
+      ref: 'original.png',
+    });
+
+    expect(result).toEqual(expected);
+    expect(api.images.upload).toHaveBeenCalledWith({
+      file: '/tmp/x.png',
+      purpose: 'icon',
+      ref: 'original.png',
+    });
+  });
+
+  it('omits purpose/ref when not provided', async () => {
+    api.images.upload.mockResolvedValue({ url: 'https://cdn/x.png' });
+    await uploadImage('/tmp/x.png');
+    expect(api.images.upload).toHaveBeenCalledWith({ file: '/tmp/x.png' });
+  });
+
+  it('accepts each allowed purpose value', async () => {
+    api.images.upload.mockResolvedValue({ url: 'https://cdn/x' });
+    for (const purpose of ['image', 'profile_image', 'icon']) {
+      await uploadImage('/tmp/x.png', { purpose });
+    }
+    expect(api.images.upload).toHaveBeenCalledTimes(3);
+  });
+
+  it('rejects unknown purpose', async () => {
+    await expect(uploadImage('/tmp/x.png', { purpose: 'banner' })).rejects.toBeInstanceOf(
+      ValidationError
+    );
+    expect(api.images.upload).not.toHaveBeenCalled();
+  });
+
+  it('rejects non-string ref', async () => {
+    await expect(uploadImage('/tmp/x.png', { ref: 42 })).rejects.toThrow(/must be a string/);
+  });
+
+  it('rejects ref longer than 200 chars', async () => {
+    await expect(uploadImage('/tmp/x.png', { ref: 'x'.repeat(201) })).rejects.toThrow(
+      /cannot exceed 200/
+    );
+  });
+
+  it('accepts ref of exactly 200 chars', async () => {
+    api.images.upload.mockResolvedValue({ url: 'https://cdn/x' });
+    await expect(uploadImage('/tmp/x.png', { ref: 'x'.repeat(200) })).resolves.toBeDefined();
+  });
+});

package/src/services/createResourceService.js

@@ -0,0 +1,138 @@
+import { GhostAPIError, ValidationError } from '../errors/index.js';
+import { handleApiRequest, readResource, updateWithOCC, deleteResource } from './ghostApiClient.js';
+import { validators } from './validators.js';
+
+/**
+ * Factory that generates standard CRUD service methods for a Ghost CMS resource.
+ *
+ * Each domain (posts, pages, tags, etc.) shares the same structural patterns:
+ * create → validate → API add → 422 mapping
+ * update → requireId → optional validation → OCC edit → optional 422 mapping
+ * remove → deleteResource
+ * getOne → readResource
+ * getList → browse with defaults → empty-array fallback
+ *
+ * Domain-specific behavior is injected via config hooks.
+ *
+ * @param {Object} config - Resource configuration
+ * @param {string} config.resource - Ghost API resource name (e.g., 'posts')
+ * @param {string} config.label - Human-readable label (e.g., 'Post')
+ * @param {Object} [config.listDefaults] - Default options for getList (e.g., { limit: 15, include: 'tags,authors' })
+ * @param {Object} [config.createDefaults] - Default data merged into create payload (e.g., { status: 'draft' })
+ * @param {Object} [config.createOptions] - Default options for create API call (e.g., { source: 'html' })
+ * @param {Function} [config.validateCreate] - Validation function called before create: (data) => void | Promise<void>
+ * @param {Function} [config.validateUpdate] - Validation function called before update: (id, data) => void | Promise<void>
+ * @param {boolean} [config.catch422OnUpdate=false] - Whether to catch 422 errors on update and wrap as ValidationError
+ * @returns {Object} Object with { create, update, remove, getOne, getList } methods
+ *
+ * SECURITY: HTML content must be sanitized before reaching this function.
+ * See htmlContentSchema in schemas/common.js for the validation gate.
+ */
+export function createResourceService(config) {
+  const {
+    resource,
+    label,
+    listDefaults = { limit: 15 },
+    createDefaults = {},
+    createOptions = {},
+    validateCreate,
+    validateUpdate,
+    catch422OnUpdate = false,
+  } = config;
+
+  /**
+   * Creates a new resource.
+   * @param {Object} data - Resource data
+   * @param {Object} [options] - API request options (merged with createOptions)
+   * @returns {Promise<Object>} Created resource
+   */
+  async function create(data, options = {}) {
+    if (validateCreate) {
+      await validateCreate(data);
+    }
+
+    const dataWithDefaults = {
+      ...createDefaults,
+      ...data,
+    };
+
+    const mergedOptions = { ...createOptions, ...options };
+
+    try {
+      return await handleApiRequest(resource, 'add', dataWithDefaults, mergedOptions);
+    } catch (error) {
+      if (error instanceof GhostAPIError && error.ghostStatusCode === 422) {
+        throw new ValidationError(`${label} creation failed due to validation errors`, [
+          { field: label.toLowerCase(), message: error.originalError },
+        ]);
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Updates an existing resource with optimistic concurrency control.
+   * @param {string} id - Resource ID
+   * @param {Object} updateData - Fields to update
+   * @param {Object} [options={}] - API request options
+   * @returns {Promise<Object>} Updated resource
+   */
+  async function update(id, updateData, options = {}) {
+    validators.requireId(id, label);
+
+    if (validateUpdate) {
+      await validateUpdate(id, updateData);
+    }
+
+    if (catch422OnUpdate) {
+      try {
+        return await updateWithOCC(resource, id, updateData, options, label);
+      } catch (error) {
+        if (error instanceof GhostAPIError && error.ghostStatusCode === 422) {
+          throw new ValidationError(`${label} update failed`, [
+            { field: label.toLowerCase(), message: error.originalError },
+          ]);
+        }
+        throw error;
+      }
+    }
+
+    return updateWithOCC(resource, id, updateData, options, label);
+  }
+
+  /**
+   * Deletes a resource by ID.
+   * @param {string} id - Resource ID
+   * @returns {Promise<Object>} Deletion confirmation
+   */
+  async function remove(id) {
+    return deleteResource(resource, id, label);
+  }
+
+  /**
+   * Retrieves a single resource by ID.
+   * @param {string} id - Resource ID
+   * @param {Object} [options={}] - API request options
+   * @returns {Promise<Object>} Resource object
+   */
+  async function getOne(id, options = {}) {
+    return readResource(resource, id, label, options);
+  }
+
+  /**
+   * Lists resources with optional filtering and pagination.
+   * @param {Object} [options={}] - Query options
+   * @returns {Promise<Array>} Array of resources (empty array if none found)
+   */
+  async function getList(options = {}) {
+    const mergedOptions = {
+      ...listDefaults,
+      ...options,
+    };
+
+    const result = await handleApiRequest(resource, 'browse', {}, mergedOptions);
+    return result || [];
+  }
+
+  return { create, update, remove, getOne, getList };
+}