@jgardner04/ghost-mcp-server 1.13.3 → 1.13.5

package/src/services/images.js

@@ -0,0 +1,27 @@
+import { GhostAPIError, ValidationError } from '../errors/index.js';
+import { handleApiRequest } from './ghostApiClient.js';
+import { validators } from './validators.js';
+
+/**
+ * Uploads an image to Ghost CMS from a local file path.
+ * @param {string} imagePath - Absolute path to the image file
+ * @returns {Promise<Object>} The uploaded image object with URL
+ * @throws {ValidationError} If the path is invalid or upload fails
+ * @throws {NotFoundError} If the file does not exist
+ * @throws {GhostAPIError} If the API request fails
+ */
+export async function uploadImage(imagePath) {
+  // Validate input
+  await validators.validateImagePath(imagePath);
+
+  const imageData = { file: imagePath };
+
+  try {
+    return await handleApiRequest('images', 'upload', imageData);
+  } catch (error) {
+    if (error instanceof GhostAPIError) {
+      throw new ValidationError(`Image upload failed: ${error.originalError}`);
+    }
+    throw error;
+  }
+}

package/src/services/members.js

@@ -0,0 +1,127 @@
+import { GhostAPIError, NotFoundError } from '../errors/index.js';
+import { sanitizeNqlValue } from '../utils/nqlSanitizer.js';
+import { handleApiRequest } from './ghostApiClient.js';
+import { createResourceService } from './createResourceService.js';
+
+const service = createResourceService({
+  resource: 'members',
+  label: 'Member',
+  listDefaults: { limit: 15 },
+  // Input validation is performed at the MCP tool layer using Zod schemas
+});
+
+/**
+ * Creates a new member (subscriber) in Ghost CMS
+ * @param {Object} memberData - The member data
+ * @param {string} memberData.email - Member email (required)
+ * @param {string} [memberData.name] - Member name
+ * @param {string} [memberData.note] - Notes about the member (HTML will be sanitized)
+ * @param {string[]} [memberData.labels] - Array of label names
+ * @param {Object[]} [memberData.newsletters] - Array of newsletter objects with id
+ * @param {boolean} [memberData.subscribed] - Email subscription status
+ * @param {Object} [options] - Additional options for the API request
+ * @returns {Promise<Object>} The created member object
+ * @throws {ValidationError} If validation fails
+ * @throws {GhostAPIError} If the API request fails
+ */
+export const createMember = service.create;
+
+/**
+ * Updates an existing member in Ghost CMS
+ * @param {string} memberId - The member ID to update
+ * @param {Object} updateData - The member update data
+ * @param {string} [updateData.email] - Member email
+ * @param {string} [updateData.name] - Member name
+ * @param {string} [updateData.note] - Notes about the member (HTML will be sanitized)
+ * @param {string[]} [updateData.labels] - Array of label names
+ * @param {Object[]} [updateData.newsletters] - Array of newsletter objects with id
+ * @param {boolean} [updateData.subscribed] - Email subscription status
+ * @param {Object} [options] - Additional options for the API request
+ * @returns {Promise<Object>} The updated member object
+ * @throws {ValidationError} If validation fails
+ * @throws {NotFoundError} If the member is not found
+ * @throws {GhostAPIError} If the API request fails
+ */
+export const updateMember = service.update;
+
+/**
+ * Deletes a member from Ghost CMS
+ * @param {string} memberId - The member ID to delete
+ * @returns {Promise<Object>} Deletion confirmation object
+ * @throws {ValidationError} If member ID is not provided
+ * @throws {NotFoundError} If the member is not found
+ * @throws {GhostAPIError} If the API request fails
+ */
+export const deleteMember = service.remove;
+
+/**
+ * List members from Ghost CMS with optional filtering and pagination
+ * @param {Object} [options] - Query options
+ * @param {number} [options.limit] - Number of members to return (1-100)
+ * @param {number} [options.page] - Page number (1+)
+ * @param {string} [options.filter] - NQL filter string (e.g., 'status:paid')
+ * @param {string} [options.order] - Order string (e.g., 'created_at desc')
+ * @param {string} [options.include] - Include string (e.g., 'labels,newsletters')
+ * @returns {Promise<Array>} Array of member objects
+ * @throws {ValidationError} If validation fails
+ * @throws {GhostAPIError} If the API request fails
+ */
+export const getMembers = service.getList;
+
+/**
+ * Get a single member from Ghost CMS by ID or email
+ * @param {Object} params - Lookup parameters (id OR email required)
+ * @param {string} [params.id] - Member ID
+ * @param {string} [params.email] - Member email
+ * @returns {Promise<Object>} The member object
+ * @throws {ValidationError} If validation fails
+ * @throws {NotFoundError} If the member is not found
+ * @throws {GhostAPIError} If the API request fails
+ */
+export async function getMember(params) {
+  const { id, email } = params;
+
+  try {
+    if (id) {
+      return await handleApiRequest('members', 'read', { id }, { id });
+    } else {
+      const sanitizedEmail = sanitizeNqlValue(email);
+      const members = await handleApiRequest(
+        'members',
+        'browse',
+        {},
+        { filter: `email:'${sanitizedEmail}'`, limit: 1 }
+      );
+
+      if (!members || members.length === 0) {
+        throw new NotFoundError('Member', email);
+      }
+
+      return members[0];
+    }
+  } catch (error) {
+    if (error instanceof GhostAPIError && error.ghostStatusCode === 404) {
+      throw new NotFoundError('Member', id || email);
+    }
+    throw error;
+  }
+}
+
+/**
+ * Search members by name or email
+ * @param {string} query - Search query (searches name and email fields)
+ * @param {Object} [options] - Additional options
+ * @param {number} [options.limit] - Maximum number of results (default: 15)
+ * @returns {Promise<Array>} Array of matching member objects
+ * @throws {ValidationError} If validation fails
+ * @throws {GhostAPIError} If the API request fails
+ */
+export async function searchMembers(query, options = {}) {
+  const sanitizedQuery = sanitizeNqlValue(query.trim());
+  const limit = options.limit || 15;
+
+  const filter = `name:~'${sanitizedQuery}',email:~'${sanitizedQuery}'`;
+
+  const members = await handleApiRequest('members', 'browse', {}, { filter, limit });
+  return members || [];
+}

package/src/services/newsletters.js

@@ -0,0 +1,63 @@
+import { createResourceService } from './createResourceService.js';
+import { validators } from './validators.js';
+
+const service = createResourceService({
+  resource: 'newsletters',
+  label: 'Newsletter',
+  listDefaults: { limit: 'all' },
+  validateCreate: (data) => validators.validateNewsletterData(data),
+  catch422OnUpdate: true,
+});
+
+/**
+ * Lists all newsletters with optional filtering and pagination.
+ * @param {Object} [options={}] - Query options
+ * @param {string|number} [options.limit='all'] - Number of newsletters to return (default: 'all')
+ * @returns {Promise<Array>} Array of newsletter objects (empty array if none found)
+ * @throws {GhostAPIError} If the API request fails
+ */
+export const getNewsletters = service.getList;
+
+/**
+ * Retrieves a single newsletter by ID.
+ * @param {string} newsletterId - The newsletter ID to retrieve
+ * @returns {Promise<Object>} The newsletter object
+ * @throws {ValidationError} If the newsletter ID is missing
+ * @throws {NotFoundError} If the newsletter is not found
+ * @throws {GhostAPIError} If the API request fails
+ */
+export const getNewsletter = service.getOne;
+
+/**
+ * Creates a new newsletter in Ghost CMS.
+ * @param {Object} newsletterData - The newsletter data
+ * @param {string} newsletterData.name - Newsletter name (required)
+ * @param {string} [newsletterData.description] - Newsletter description
+ * @param {string} [newsletterData.sender_name] - Sender name
+ * @param {string} [newsletterData.sender_email] - Sender email
+ * @returns {Promise<Object>} The created newsletter object
+ * @throws {ValidationError} If validation fails or Ghost returns a 422
+ * @throws {GhostAPIError} If the API request fails
+ */
+export const createNewsletter = service.create;
+
+/**
+ * Updates an existing newsletter with optimistic concurrency control.
+ * @param {string} newsletterId - The newsletter ID to update
+ * @param {Object} updateData - Fields to update on the newsletter
+ * @returns {Promise<Object>} The updated newsletter object
+ * @throws {ValidationError} If the newsletter ID is missing or Ghost returns a 422
+ * @throws {NotFoundError} If the newsletter is not found
+ * @throws {GhostAPIError} If the API request fails
+ */
+export const updateNewsletter = service.update;
+
+/**
+ * Deletes a newsletter by ID.
+ * @param {string} newsletterId - The newsletter ID to delete
+ * @returns {Promise<Object>} Deletion confirmation
+ * @throws {ValidationError} If the newsletter ID is missing
+ * @throws {NotFoundError} If the newsletter is not found
+ * @throws {GhostAPIError} If the API request fails
+ */
+export const deleteNewsletter = service.remove;

package/src/services/pages.js

@@ -0,0 +1,116 @@
+import { ValidationError } from '../errors/index.js';
+import { sanitizeNqlValue } from '../utils/nqlSanitizer.js';
+import { handleApiRequest, readResource } from './ghostApiClient.js';
+import { createResourceService } from './createResourceService.js';
+import { validators } from './validators.js';
+
+const service = createResourceService({
+  resource: 'pages',
+  label: 'Page',
+  createDefaults: { status: 'draft' },
+  createOptions: { source: 'html' },
+  listDefaults: { limit: 15, include: 'authors' },
+  validateCreate: (data) => validators.validatePageData(data),
+  validateUpdate: async (id, updateData) => {
+    if (updateData.status || updateData.published_at) {
+      let validationData = updateData;
+      if (!updateData.status && updateData.published_at) {
+        const existing = await readResource('pages', id, 'Page');
+        validationData = { ...updateData, status: existing.status };
+      }
+      validators.validateScheduledStatus(validationData, 'Page');
+    }
+  },
+});
+
+/**
+ * Creates a new page in Ghost CMS.
+ * @param {Object} pageData - The page data
+ * @param {string} pageData.title - Page title (required)
+ * @param {string} [pageData.html] - HTML content (required if mobiledoc not provided)
+ * @param {string} [pageData.mobiledoc] - Mobiledoc content (required if html not provided)
+ * @param {string} [pageData.status='draft'] - Page status ('draft', 'published', 'scheduled')
+ * @param {string} [pageData.published_at] - ISO 8601 date for scheduled pages
+ * @param {Object} [options={ source: 'html' }] - API request options
+ * @returns {Promise<Object>} The created page object
+ * @throws {ValidationError} If validation fails or Ghost returns a 422
+ * @throws {GhostAPIError} If the API request fails
+ */
+export const createPage = service.create;
+
+/**
+ * Updates an existing page with optimistic concurrency control.
+ * Validates scheduling fields when status or published_at is being changed.
+ * @param {string} pageId - The page ID to update
+ * @param {Object} updateData - Fields to update on the page
+ * @param {Object} [options={}] - API request options
+ * @returns {Promise<Object>} The updated page object
+ * @throws {ValidationError} If the page ID is missing or scheduling validation fails
+ * @throws {NotFoundError} If the page is not found
+ * @throws {GhostAPIError} If the API request fails
+ */
+export const updatePage = service.update;
+
+/**
+ * Deletes a page by ID.
+ * @param {string} pageId - The page ID to delete
+ * @returns {Promise<Object>} Deletion confirmation
+ * @throws {ValidationError} If the page ID is missing
+ * @throws {NotFoundError} If the page is not found
+ * @throws {GhostAPIError} If the API request fails
+ */
+export const deletePage = service.remove;
+
+/**
+ * Retrieves a single page by ID.
+ * @param {string} pageId - The page ID to retrieve
+ * @param {Object} [options={}] - API request options (e.g., includes)
+ * @returns {Promise<Object>} The page object
+ * @throws {ValidationError} If the page ID is missing
+ * @throws {NotFoundError} If the page is not found
+ * @throws {GhostAPIError} If the API request fails
+ */
+export const getPage = service.getOne;
+
+/**
+ * Lists pages with optional filtering and pagination.
+ * @param {Object} [options={}] - Query options
+ * @param {number} [options.limit=15] - Number of pages to return
+ * @param {string} [options.include='authors'] - Related resources to include
+ * @param {string} [options.filter] - NQL filter string
+ * @param {string} [options.order] - Order string
+ * @returns {Promise<Array>} Array of page objects
+ * @throws {GhostAPIError} If the API request fails
+ */
+export const getPages = service.getList;
+
+/**
+ * Searches pages by title using Ghost NQL fuzzy matching.
+ * @param {string} query - Search query string (required, non-empty)
+ * @param {Object} [options={}] - Additional search options
+ * @param {string} [options.status] - Filter by status ('draft', 'published', 'scheduled', or 'all')
+ * @param {number} [options.limit=15] - Maximum number of results
+ * @returns {Promise<Array>} Array of matching page objects
+ * @throws {ValidationError} If the query is empty
+ * @throws {GhostAPIError} If the API request fails
+ */
+export async function searchPages(query, options = {}) {
+  if (!query || query.trim().length === 0) {
+    throw new ValidationError('Search query is required');
+  }
+
+  const sanitizedQuery = sanitizeNqlValue(query);
+
+  const filterParts = [`title:~'${sanitizedQuery}'`];
+  if (options.status && options.status !== 'all') {
+    filterParts.push(`status:${options.status}`);
+  }
+
+  const searchOptions = {
+    limit: options.limit || 15,
+    include: 'authors',
+    filter: filterParts.join('+'),
+  };
+
+  return handleApiRequest('pages', 'browse', {}, searchOptions);
+}

package/src/services/posts.js

@@ -0,0 +1,116 @@
+import { ValidationError } from '../errors/index.js';
+import { sanitizeNqlValue } from '../utils/nqlSanitizer.js';
+import { handleApiRequest, readResource } from './ghostApiClient.js';
+import { createResourceService } from './createResourceService.js';
+import { validators } from './validators.js';
+
+const service = createResourceService({
+  resource: 'posts',
+  label: 'Post',
+  createDefaults: { status: 'draft' },
+  createOptions: { source: 'html' },
+  listDefaults: { limit: 15, include: 'tags,authors' },
+  validateCreate: (data) => validators.validatePostData(data),
+  validateUpdate: async (id, updateData) => {
+    if (updateData.status || updateData.published_at) {
+      let validationData = updateData;
+      if (!updateData.status && updateData.published_at) {
+        const existing = await readResource('posts', id, 'Post');
+        validationData = { ...updateData, status: existing.status };
+      }
+      validators.validateScheduledStatus(validationData, 'Post');
+    }
+  },
+});
+
+/**
+ * Creates a new post in Ghost CMS.
+ * @param {Object} postData - The post data
+ * @param {string} postData.title - Post title (required)
+ * @param {string} [postData.html] - HTML content (required if mobiledoc not provided)
+ * @param {string} [postData.mobiledoc] - Mobiledoc content (required if html not provided)
+ * @param {string} [postData.status='draft'] - Post status ('draft', 'published', 'scheduled')
+ * @param {string} [postData.published_at] - ISO 8601 date for scheduled posts
+ * @param {Object} [options={ source: 'html' }] - API request options
+ * @returns {Promise<Object>} The created post object
+ * @throws {ValidationError} If validation fails or Ghost returns a 422
+ * @throws {GhostAPIError} If the API request fails
+ */
+export const createPost = service.create;
+
+/**
+ * Updates an existing post with optimistic concurrency control.
+ * Validates scheduling fields when status or published_at is being changed.
+ * @param {string} postId - The post ID to update
+ * @param {Object} updateData - Fields to update on the post
+ * @param {Object} [options={}] - API request options
+ * @returns {Promise<Object>} The updated post object
+ * @throws {ValidationError} If the post ID is missing or scheduling validation fails
+ * @throws {NotFoundError} If the post is not found
+ * @throws {GhostAPIError} If the API request fails
+ */
+export const updatePost = service.update;
+
+/**
+ * Deletes a post by ID.
+ * @param {string} postId - The post ID to delete
+ * @returns {Promise<Object>} Deletion confirmation
+ * @throws {ValidationError} If the post ID is missing
+ * @throws {NotFoundError} If the post is not found
+ * @throws {GhostAPIError} If the API request fails
+ */
+export const deletePost = service.remove;
+
+/**
+ * Retrieves a single post by ID.
+ * @param {string} postId - The post ID to retrieve
+ * @param {Object} [options={}] - API request options (e.g., includes)
+ * @returns {Promise<Object>} The post object
+ * @throws {ValidationError} If the post ID is missing
+ * @throws {NotFoundError} If the post is not found
+ * @throws {GhostAPIError} If the API request fails
+ */
+export const getPost = service.getOne;
+
+/**
+ * Lists posts with optional filtering and pagination.
+ * @param {Object} [options={}] - Query options
+ * @param {number} [options.limit=15] - Number of posts to return
+ * @param {string} [options.include='tags,authors'] - Related resources to include
+ * @param {string} [options.filter] - NQL filter string
+ * @param {string} [options.order] - Order string (e.g., 'published_at desc')
+ * @returns {Promise<Array>} Array of post objects
+ * @throws {GhostAPIError} If the API request fails
+ */
+export const getPosts = service.getList;
+
+/**
+ * Searches posts by title using Ghost NQL fuzzy matching.
+ * @param {string} query - Search query string (required, non-empty)
+ * @param {Object} [options={}] - Additional search options
+ * @param {string} [options.status] - Filter by status ('draft', 'published', 'scheduled', or 'all')
+ * @param {number} [options.limit=15] - Maximum number of results
+ * @returns {Promise<Array>} Array of matching post objects
+ * @throws {ValidationError} If the query is empty
+ * @throws {GhostAPIError} If the API request fails
+ */
+export async function searchPosts(query, options = {}) {
+  if (!query || query.trim().length === 0) {
+    throw new ValidationError('Search query is required');
+  }
+
+  const sanitizedQuery = sanitizeNqlValue(query);
+
+  const filterParts = [`title:~'${sanitizedQuery}'`];
+  if (options.status && options.status !== 'all') {
+    filterParts.push(`status:${options.status}`);
+  }
+
+  const searchOptions = {
+    limit: options.limit || 15,
+    include: 'tags,authors',
+    filter: filterParts.join('+'),
+  };
+
+  return handleApiRequest('posts', 'browse', {}, searchOptions);
+}

package/src/services/tags.js

@@ -0,0 +1,118 @@
+import { GhostAPIError, ValidationError, NotFoundError } from '../errors/index.js';
+import { sanitizeNqlValue } from '../utils/nqlSanitizer.js';
+import { handleApiRequest, readResource } from './ghostApiClient.js';
+import { createResourceService } from './createResourceService.js';
+import { validators } from './validators.js';
+
+const service = createResourceService({
+  resource: 'tags',
+  label: 'Tag',
+  listDefaults: { limit: 15 },
+});
+
+/**
+ * Creates a new tag in Ghost CMS. Auto-generates a slug from the name if not provided.
+ * If a tag with the same name already exists, returns the existing tag instead of failing.
+ * @param {Object} tagData - The tag data
+ * @param {string} tagData.name - Tag name (required)
+ * @param {string} [tagData.slug] - Tag slug (auto-generated from name if omitted)
+ * @param {string} [tagData.description] - Tag description
+ * @returns {Promise<Object>} The created (or existing) tag object
+ * @throws {ValidationError} If validation fails or Ghost returns a 422 (non-duplicate)
+ * @throws {GhostAPIError} If the API request fails
+ */
+export async function createTag(tagData) {
+  validators.validateTagData(tagData);
+
+  const dataToCreate = tagData.slug
+    ? { ...tagData }
+    : {
+        ...tagData,
+        slug: tagData.name
+          .toLowerCase()
+          .replace(/[^a-z0-9]+/g, '-')
+          .replace(/^-+|-+$/g, ''),
+      };
+
+  try {
+    return await handleApiRequest('tags', 'add', dataToCreate);
+  } catch (error) {
+    if (error instanceof GhostAPIError && error.ghostStatusCode === 422) {
+      if (error.originalError.includes('already exists')) {
+        const existingTags = await getTags({ filter: `name:'${sanitizeNqlValue(tagData.name)}'` });
+        if (existingTags.length > 0) {
+          return existingTags[0];
+        }
+      }
+      throw new ValidationError('Tag creation failed', [
+        { field: 'tag', message: error.originalError },
+      ]);
+    }
+    throw error;
+  }
+}
+
+/**
+ * Lists tags with optional filtering and pagination.
+ * @param {Object} [options={}] - Query options
+ * @param {number} [options.limit=15] - Number of tags to return
+ * @param {string} [options.filter] - NQL filter string
+ * @param {string} [options.order] - Order string
+ * @returns {Promise<Array>} Array of tag objects (empty array if none found)
+ * @throws {GhostAPIError} If the API request fails
+ */
+export const getTags = service.getList;
+
+/**
+ * Retrieves a single tag by ID.
+ * @param {string} tagId - The tag ID to retrieve
+ * @param {Object} [options={}] - API request options
+ * @returns {Promise<Object>} The tag object
+ * @throws {ValidationError} If the tag ID is missing
+ * @throws {NotFoundError} If the tag is not found
+ * @throws {GhostAPIError} If the API request fails
+ */
+export const getTag = service.getOne;
+
+/**
+ * Updates an existing tag. Validates update data and checks that the tag exists first.
+ * Tags use direct edit (not OCC) since they don't have concurrent editing concerns.
+ * @param {string} tagId - The tag ID to update
+ * @param {Object} updateData - Fields to update on the tag
+ * @param {string} [updateData.name] - Updated tag name
+ * @param {string} [updateData.slug] - Updated tag slug
+ * @param {string} [updateData.description] - Updated tag description
+ * @returns {Promise<Object>} The updated tag object
+ * @throws {ValidationError} If the tag ID is missing or update data is invalid
+ * @throws {NotFoundError} If the tag is not found
+ * @throws {GhostAPIError} If the API request fails
+ */
+export async function updateTag(tagId, updateData) {
+  validators.requireId(tagId, 'Tag');
+  validators.validateTagUpdateData(updateData);
+
+  try {
+    await readResource('tags', tagId, 'Tag');
+    return await handleApiRequest('tags', 'edit', { id: tagId, ...updateData });
+  } catch (error) {
+    if (error instanceof NotFoundError) {
+      throw error;
+    }
+    if (error instanceof GhostAPIError && error.ghostStatusCode === 422) {
+      throw new ValidationError('Tag update failed', [
+        { field: 'tag', message: error.originalError },
+      ]);
+    }
+    throw error;
+  }
+}
+
+/**
+ * Deletes a tag by ID.
+ * @param {string} tagId - The tag ID to delete
+ * @returns {Promise<Object>} Deletion confirmation
+ * @throws {ValidationError} If the tag ID is missing
+ * @throws {NotFoundError} If the tag is not found
+ * @throws {GhostAPIError} If the API request fails
+ */
+export const deleteTag = service.remove;

package/src/services/tiers.js

@@ -0,0 +1,72 @@
+import { createResourceService } from './createResourceService.js';
+import {
+  validateTierData,
+  validateTierUpdateData,
+  validateTierQueryOptions,
+} from './tierService.js';
+
+const service = createResourceService({
+  resource: 'tiers',
+  label: 'Tier',
+  listDefaults: { limit: 15 },
+  validateCreate: (data) => validateTierData(data),
+  validateUpdate: (_id, data) => validateTierUpdateData(data),
+});
+
+/**
+ * Create a new tier (membership level)
+ * @param {Object} tierData - Tier data
+ * @param {Object} [options={}] - Options for the API request
+ * @returns {Promise<Object>} Created tier
+ * @throws {ValidationError} If validation fails or Ghost returns a 422
+ * @throws {GhostAPIError} If the API request fails
+ */
+export const createTier = service.create;
+
+/**
+ * Update an existing tier with optimistic concurrency control.
+ * @param {string} id - Tier ID
+ * @param {Object} updateData - Tier update data
+ * @param {Object} [options={}] - Options for the API request
+ * @returns {Promise<Object>} Updated tier
+ * @throws {ValidationError} If the tier ID is missing or update data is invalid
+ * @throws {NotFoundError} If the tier is not found
+ * @throws {GhostAPIError} If the API request fails
+ */
+export const updateTier = service.update;
+
+/**
+ * Delete a tier by ID.
+ * @param {string} id - Tier ID
+ * @returns {Promise<Object>} Deletion result
+ * @throws {ValidationError} If the tier ID is missing
+ * @throws {NotFoundError} If the tier is not found
+ * @throws {GhostAPIError} If the API request fails
+ */
+export const deleteTier = service.remove;
+
+/**
+ * Get all tiers with optional filtering
+ * @param {Object} [options={}] - Query options
+ * @param {number} [options.limit] - Number of tiers to return (1-100, default 15)
+ * @param {number} [options.page] - Page number
+ * @param {string} [options.filter] - NQL filter string (e.g., "type:paid", "type:free")
+ * @param {string} [options.order] - Order string
+ * @param {string} [options.include] - Include string
+ * @returns {Promise<Array>} Array of tiers
+ * @throws {GhostAPIError} If the API request fails
+ */
+export async function getTiers(options = {}) {
+  validateTierQueryOptions(options);
+  return service.getList(options);
+}
+
+/**
+ * Get a single tier by ID.
+ * @param {string} id - Tier ID
+ * @returns {Promise<Object>} Tier object
+ * @throws {ValidationError} If the tier ID is missing
+ * @throws {NotFoundError} If the tier is not found
+ * @throws {GhostAPIError} If the API request fails
+ */
+export const getTier = service.getOne;