// WordPress Pages Service
import { AxiosInstance } from 'axios';
import { logger } from '../../utils/logger.js';
import { ErrorHandler } from '../../utils/error-handler.js';
export interface PageCreateData {
title: string;
content: string;
status?: 'publish' | 'draft' | 'pending' | 'private' | 'future';
excerpt?: string;
author?: number;
featured_media?: number;
parent?: number;
menu_order?: number;
comment_status?: 'open' | 'closed';
ping_status?: 'open' | 'closed';
template?: string;
meta?: Record<string, any>;
}
export interface PageUpdateData extends Partial<PageCreateData> {
id: number;
}
export interface PageQueryParams {
per_page?: number;
page?: number;
status?: string;
search?: string;
author?: number;
parent?: number;
order?: 'asc' | 'desc';
orderby?: 'date' | 'relevance' | 'id' | 'title' | 'slug' | 'menu_order';
}
export class PagesService {
constructor(private client: AxiosInstance) {}
async createPage(data: PageCreateData): Promise<any> {
return ErrorHandler.wrapAsync(async () => {
logger.info('Creating new page', { title: data.title });
const response = await this.client.post('/pages', data);
logger.info('Page created successfully', { id: response.data.id });
return response.data;
}, 'PagesService.createPage');
}
async getPage(id: number, context: 'view' | 'edit' = 'edit'): Promise<any> {
return ErrorHandler.wrapAsync(async () => {
logger.debug(`Fetching page ${id}`);
const response = await this.client.get(`/pages/${id}`, {
params: { context }
});
return response.data;
}, 'PagesService.getPage');
}
async getPageBySlug(slug: string): Promise<any> {
return ErrorHandler.wrapAsync(async () => {
logger.debug(`Fetching page by slug: ${slug}`);
const response = await this.client.get('/pages', {
params: { slug, _fields: 'id,title,slug,status' }
});
if (response.data && response.data.length > 0) {
return response.data[0];
}
throw new Error(`Page with slug '${slug}' not found`);
}, 'PagesService.getPageBySlug');
}
async updatePage(data: PageUpdateData): Promise<any> {
return ErrorHandler.wrapAsync(async () => {
const { id, ...updateData } = data;
logger.info(`Updating page ${id}`);
const response = await this.client.post(`/pages/${id}`, updateData);
logger.info('Page updated successfully', { id });
return response.data;
}, 'PagesService.updatePage');
}
async deletePage(id: number, force: boolean = false): Promise<any> {
return ErrorHandler.wrapAsync(async () => {
logger.info(`Deleting page ${id}`, { force });
const response = await this.client.delete(`/pages/${id}`, {
params: { force }
});
logger.info('Page deleted successfully', { id });
return response.data;
}, 'PagesService.deletePage');
}
async listPages(params: PageQueryParams = {}): Promise<any> {
return ErrorHandler.wrapAsync(async () => {
const defaultParams = {
per_page: 10,
status: 'any',
...params
};
logger.debug('Listing pages', defaultParams);
const response = await this.client.get('/pages', {
params: defaultParams
});
logger.debug(`Found ${response.data.length} pages`);
return {
pages: response.data,
total: response.headers['x-wp-total'],
totalPages: response.headers['x-wp-totalpages']
};
}, 'PagesService.listPages');
}
async searchPages(searchTerm: string, params: Omit<PageQueryParams, 'search'> = {}): Promise<any> {
return this.listPages({ ...params, search: searchTerm });
}
async getChildPages(parentId: number, params: Omit<PageQueryParams, 'parent'> = {}): Promise<any> {
return this.listPages({ ...params, parent: parentId });
}
async listAllContent(perPage: number = 50, includeAllStatuses: boolean = false): Promise<any> {
return ErrorHandler.wrapAsync(async () => {
const status = includeAllStatuses ? 'any' : 'publish';
const [pages, posts] = await Promise.all([
this.listPages({ per_page: perPage, status }),
// We'll need posts service here, but for now return pages only
Promise.resolve({ posts: [], total: 0, totalPages: 0 })
]);
return {
pages: pages.pages,
posts: posts.posts,
totalPages: pages.total,
totalPosts: posts.total
};
}, 'PagesService.listAllContent');
}
}