wp-astrojs-integration 0.1.0

package/dist/client/index.js

@@ -0,0 +1,164 @@
+import { createBasicAuthHeader } from './auth';
+import { createPostsMethods } from './posts';
+import { createPagesMethods } from './pages';
+import { createMediaMethods } from './media';
+import { createCategoriesMethods } from './categories';
+import { createTagsMethods } from './tags';
+import { createUsersMethods } from './users';
+import { createSettingsMethods } from './settings';
+/**
+ * WordPress API Client
+ * Provides direct access to WordPress REST API endpoints
+ * Used internally by loaders and available for runtime data fetching
+ *
+ * @example
+ * // Without auth
+ * const wp = new WordPressClient({ baseUrl: 'https://example.com' });
+ *
+ * @example
+ * // With auth
+ * const wp = new WordPressClient({
+ *   baseUrl: 'https://example.com',
+ *   auth: { username: 'admin', password: 'app-password' }
+ * });
+ */
+export class WordPressClient {
+    baseUrl;
+    apiBase;
+    authHeader;
+    // Posts methods
+    getPosts;
+    getAllPosts;
+    getPostsPaginated;
+    getPost;
+    getPostBySlug;
+    // Pages methods
+    getPages;
+    getAllPages;
+    getPagesPaginated;
+    getPage;
+    getPageBySlug;
+    // Media methods
+    getMedia;
+    getAllMedia;
+    getMediaPaginated;
+    getMediaItem;
+    getMediaBySlug;
+    getImageUrl;
+    // Categories methods
+    getCategories;
+    getAllCategories;
+    getCategoriesPaginated;
+    getCategory;
+    getCategoryBySlug;
+    // Tags methods
+    getTags;
+    getAllTags;
+    getTagsPaginated;
+    getTag;
+    getTagBySlug;
+    // Users methods
+    getUsers;
+    getAllUsers;
+    getUsersPaginated;
+    getUser;
+    getCurrentUser;
+    // Settings methods
+    getSettings;
+    constructor(config) {
+        this.baseUrl = config.baseUrl;
+        this.authHeader = config.auth ? createBasicAuthHeader(config.auth) : undefined;
+        this.apiBase = `${this.baseUrl}/index.php?rest_route=/wp/v2`;
+        // Bind fetchAPI and hasAuth for resource methods
+        const fetchAPI = this.fetchAPI.bind(this);
+        const fetchAPIPaginated = this.fetchAPIPaginated.bind(this);
+        const hasAuth = this.hasAuth.bind(this);
+        // Initialize resource methods
+        const posts = createPostsMethods(fetchAPI, fetchAPIPaginated);
+        this.getPosts = posts.getPosts;
+        this.getAllPosts = posts.getAllPosts;
+        this.getPostsPaginated = posts.getPostsPaginated;
+        this.getPost = posts.getPost;
+        this.getPostBySlug = posts.getPostBySlug;
+        const pages = createPagesMethods(fetchAPI, fetchAPIPaginated);
+        this.getPages = pages.getPages;
+        this.getAllPages = pages.getAllPages;
+        this.getPagesPaginated = pages.getPagesPaginated;
+        this.getPage = pages.getPage;
+        this.getPageBySlug = pages.getPageBySlug;
+        const media = createMediaMethods(fetchAPI, fetchAPIPaginated);
+        this.getMedia = media.getMedia;
+        this.getAllMedia = media.getAllMedia;
+        this.getMediaPaginated = media.getMediaPaginated;
+        this.getMediaItem = media.getMediaItem;
+        this.getMediaBySlug = media.getMediaBySlug;
+        this.getImageUrl = media.getImageUrl;
+        const categories = createCategoriesMethods(fetchAPI, fetchAPIPaginated);
+        this.getCategories = categories.getCategories;
+        this.getAllCategories = categories.getAllCategories;
+        this.getCategoriesPaginated = categories.getCategoriesPaginated;
+        this.getCategory = categories.getCategory;
+        this.getCategoryBySlug = categories.getCategoryBySlug;
+        const tags = createTagsMethods(fetchAPI, fetchAPIPaginated);
+        this.getTags = tags.getTags;
+        this.getAllTags = tags.getAllTags;
+        this.getTagsPaginated = tags.getTagsPaginated;
+        this.getTag = tags.getTag;
+        this.getTagBySlug = tags.getTagBySlug;
+        const users = createUsersMethods(fetchAPI, fetchAPIPaginated, hasAuth);
+        this.getUsers = users.getUsers;
+        this.getAllUsers = users.getAllUsers;
+        this.getUsersPaginated = users.getUsersPaginated;
+        this.getUser = users.getUser;
+        this.getCurrentUser = users.getCurrentUser;
+        const settings = createSettingsMethods(fetchAPI, hasAuth);
+        this.getSettings = settings.getSettings;
+    }
+    /**
+     * Checks if authentication is configured
+     */
+    hasAuth() {
+        return this.authHeader !== undefined;
+    }
+    /**
+     * Fetches data from WordPress REST API
+     * Auth header is automatically added if configured
+     *
+     * @param endpoint - API endpoint path (e.g., '/posts', '/settings')
+     * @param params - Query parameters to append to the request
+     */
+    async fetchAPI(endpoint, params = {}) {
+        const result = await this.fetchAPIPaginated(endpoint, params);
+        return result.data;
+    }
+    /**
+     * Fetches data from WordPress REST API with pagination info
+     * Auth header is automatically added if configured
+     *
+     * @param endpoint - API endpoint path (e.g., '/posts', '/settings')
+     * @param params - Query parameters to append to the request
+     * @returns Object with data and pagination headers
+     */
+    async fetchAPIPaginated(endpoint, params = {}) {
+        const startTime = performance.now();
+        const url = new URL(`${this.apiBase}${endpoint}`);
+        Object.entries(params).forEach(([key, value]) => url.searchParams.append(key, value));
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        if (this.authHeader) {
+            headers['Authorization'] = this.authHeader;
+        }
+        const response = await fetch(url.toString(), { headers });
+        if (!response.ok) {
+            throw new Error(`WordPress API error: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        const duration = Math.round(performance.now() - startTime);
+        console.log(`[WP API] ${endpoint} - ${duration}ms - params:`, JSON.stringify(params));
+        // Extract pagination headers
+        const total = parseInt(response.headers.get('X-WP-Total') || '0', 10);
+        const totalPages = parseInt(response.headers.get('X-WP-TotalPages') || '0', 10);
+        return { data, total, totalPages };
+    }
+}

package/dist/client/media.d.ts

@@ -0,0 +1,47 @@
+import type { WordPressMedia } from '../schemas';
+import type { FetchResult } from './index';
+import type { MediaFilter, PaginatedResponse } from './types';
+/**
+ * Media API methods factory
+ * Creates type-safe methods for fetching WordPress media with filtering and pagination
+ */
+export declare function createMediaMethods(fetchAPI: <T>(endpoint: string, params?: Record<string, string>) => Promise<T>, fetchAPIPaginated: <T>(endpoint: string, params?: Record<string, string>) => Promise<FetchResult<T>>): {
+    /**
+     * Gets media items with optional filtering (single page, max 100 items)
+     *
+     * @param filter - Filter options (mediaType, mimeType, author, parent, etc.)
+     * @returns Array of media items matching the filter criteria
+     */
+    getMedia(filter?: MediaFilter): Promise<WordPressMedia[]>;
+    /**
+     * Gets ALL media items by automatically paginating through all pages
+     * Use this for static site generation to ensure all content is fetched
+     *
+     * @param filter - Filter options (mediaType, mimeType, author, parent, etc.)
+     * @returns Array of all media items matching the filter criteria
+     */
+    getAllMedia(filter?: Omit<MediaFilter, "page">): Promise<WordPressMedia[]>;
+    /**
+     * Gets media items with pagination metadata
+     *
+     * @param filter - Filter options including pagination (perPage, page)
+     * @returns Paginated response with media items and total counts
+     */
+    getMediaPaginated(filter?: MediaFilter): Promise<PaginatedResponse<WordPressMedia>>;
+    /**
+     * Gets a single media item by ID
+     */
+    getMediaItem(id: number): Promise<WordPressMedia>;
+    /**
+     * Gets a single media item by slug
+     */
+    getMediaBySlug(slug: string): Promise<WordPressMedia | undefined>;
+    /**
+     * Gets the URL for a specific media size
+     *
+     * @param media - WordPress media object
+     * @param size - Size name (e.g., 'thumbnail', 'medium', 'large', 'full')
+     * @returns Image URL for the specified size
+     */
+    getImageUrl(media: WordPressMedia, size?: string): string;
+};

package/dist/client/media.js

@@ -0,0 +1,82 @@
+import { filterToParams } from './types';
+/**
+ * Media API methods factory
+ * Creates type-safe methods for fetching WordPress media with filtering and pagination
+ */
+export function createMediaMethods(fetchAPI, fetchAPIPaginated) {
+    return {
+        /**
+         * Gets media items with optional filtering (single page, max 100 items)
+         *
+         * @param filter - Filter options (mediaType, mimeType, author, parent, etc.)
+         * @returns Array of media items matching the filter criteria
+         */
+        async getMedia(filter = {}) {
+            const params = filterToParams(filter);
+            return fetchAPI('/media', params);
+        },
+        /**
+         * Gets ALL media items by automatically paginating through all pages
+         * Use this for static site generation to ensure all content is fetched
+         *
+         * @param filter - Filter options (mediaType, mimeType, author, parent, etc.)
+         * @returns Array of all media items matching the filter criteria
+         */
+        async getAllMedia(filter = {}) {
+            const allMedia = [];
+            let page = 1;
+            let totalPages = 1;
+            do {
+                const params = filterToParams({ ...filter, page, perPage: 100 });
+                const result = await fetchAPIPaginated('/media', params);
+                allMedia.push(...result.data);
+                totalPages = result.totalPages;
+                page++;
+            } while (page <= totalPages);
+            return allMedia;
+        },
+        /**
+         * Gets media items with pagination metadata
+         *
+         * @param filter - Filter options including pagination (perPage, page)
+         * @returns Paginated response with media items and total counts
+         */
+        async getMediaPaginated(filter = {}) {
+            const params = filterToParams(filter);
+            const result = await fetchAPIPaginated('/media', params);
+            return {
+                data: result.data,
+                total: result.total,
+                totalPages: result.totalPages,
+                page: filter.page || 1,
+                perPage: filter.perPage || 100,
+            };
+        },
+        /**
+         * Gets a single media item by ID
+         */
+        async getMediaItem(id) {
+            return fetchAPI(`/media/${id}`);
+        },
+        /**
+         * Gets a single media item by slug
+         */
+        async getMediaBySlug(slug) {
+            const media = await fetchAPI('/media', { slug });
+            return media[0];
+        },
+        /**
+         * Gets the URL for a specific media size
+         *
+         * @param media - WordPress media object
+         * @param size - Size name (e.g., 'thumbnail', 'medium', 'large', 'full')
+         * @returns Image URL for the specified size
+         */
+        getImageUrl(media, size = 'full') {
+            if (size === 'full' || !media.media_details.sizes[size]) {
+                return media.source_url;
+            }
+            return media.media_details.sizes[size].source_url;
+        },
+    };
+}

package/dist/client/pages.d.ts

@@ -0,0 +1,39 @@
+import type { WordPressPage } from '../schemas';
+import type { FetchResult } from './index';
+import type { PagesFilter, PaginatedResponse } from './types';
+/**
+ * Pages API methods factory
+ * Creates type-safe methods for fetching WordPress pages with filtering and pagination
+ */
+export declare function createPagesMethods(fetchAPI: <T>(endpoint: string, params?: Record<string, string>) => Promise<T>, fetchAPIPaginated: <T>(endpoint: string, params?: Record<string, string>) => Promise<FetchResult<T>>): {
+    /**
+     * Gets pages with optional filtering (single page, max 100 items)
+     *
+     * @param filter - Filter options (status, parent, author, search, etc.)
+     * @returns Array of pages matching the filter criteria
+     */
+    getPages(filter?: PagesFilter): Promise<WordPressPage[]>;
+    /**
+     * Gets ALL pages by automatically paginating through all pages
+     * Use this for static site generation to ensure all content is fetched
+     *
+     * @param filter - Filter options (status, parent, author, search, etc.)
+     * @returns Array of all pages matching the filter criteria
+     */
+    getAllPages(filter?: Omit<PagesFilter, "page">): Promise<WordPressPage[]>;
+    /**
+     * Gets pages with pagination metadata
+     *
+     * @param filter - Filter options including pagination (perPage, page)
+     * @returns Paginated response with pages and total counts
+     */
+    getPagesPaginated(filter?: PagesFilter): Promise<PaginatedResponse<WordPressPage>>;
+    /**
+     * Gets a single page by ID
+     */
+    getPage(id: number): Promise<WordPressPage>;
+    /**
+     * Gets a single page by slug
+     */
+    getPageBySlug(slug: string): Promise<WordPressPage | undefined>;
+};

package/dist/client/pages.js

@@ -0,0 +1,69 @@
+import { filterToParams } from './types';
+/**
+ * Pages API methods factory
+ * Creates type-safe methods for fetching WordPress pages with filtering and pagination
+ */
+export function createPagesMethods(fetchAPI, fetchAPIPaginated) {
+    return {
+        /**
+         * Gets pages with optional filtering (single page, max 100 items)
+         *
+         * @param filter - Filter options (status, parent, author, search, etc.)
+         * @returns Array of pages matching the filter criteria
+         */
+        async getPages(filter = {}) {
+            const params = filterToParams({ ...filter, _embed: 'true' });
+            return fetchAPI('/pages', params);
+        },
+        /**
+         * Gets ALL pages by automatically paginating through all pages
+         * Use this for static site generation to ensure all content is fetched
+         *
+         * @param filter - Filter options (status, parent, author, search, etc.)
+         * @returns Array of all pages matching the filter criteria
+         */
+        async getAllPages(filter = {}) {
+            const allPages = [];
+            let page = 1;
+            let totalPages = 1;
+            do {
+                const params = filterToParams({ ...filter, page, perPage: 100, _embed: 'true' });
+                const result = await fetchAPIPaginated('/pages', params);
+                allPages.push(...result.data);
+                totalPages = result.totalPages;
+                page++;
+            } while (page <= totalPages);
+            return allPages;
+        },
+        /**
+         * Gets pages with pagination metadata
+         *
+         * @param filter - Filter options including pagination (perPage, page)
+         * @returns Paginated response with pages and total counts
+         */
+        async getPagesPaginated(filter = {}) {
+            const params = filterToParams({ ...filter, _embed: 'true' });
+            const result = await fetchAPIPaginated('/pages', params);
+            return {
+                data: result.data,
+                total: result.total,
+                totalPages: result.totalPages,
+                page: filter.page || 1,
+                perPage: filter.perPage || 100,
+            };
+        },
+        /**
+         * Gets a single page by ID
+         */
+        async getPage(id) {
+            return fetchAPI(`/pages/${id}`, { _embed: 'true' });
+        },
+        /**
+         * Gets a single page by slug
+         */
+        async getPageBySlug(slug) {
+            const pages = await fetchAPI('/pages', { slug, _embed: 'true' });
+            return pages[0];
+        },
+    };
+}

package/dist/client/posts.d.ts

@@ -0,0 +1,39 @@
+import type { WordPressPost } from '../schemas';
+import type { FetchResult } from './index';
+import type { PostsFilter, PaginatedResponse } from './types';
+/**
+ * Posts API methods factory
+ * Creates type-safe methods for fetching WordPress posts with filtering and pagination
+ */
+export declare function createPostsMethods(fetchAPI: <T>(endpoint: string, params?: Record<string, string>) => Promise<T>, fetchAPIPaginated: <T>(endpoint: string, params?: Record<string, string>) => Promise<FetchResult<T>>): {
+    /**
+     * Gets posts with optional filtering (single page, max 100 items)
+     *
+     * @param filter - Filter options (status, categories, tags, author, search, etc.)
+     * @returns Array of posts matching the filter criteria
+     */
+    getPosts(filter?: PostsFilter): Promise<WordPressPost[]>;
+    /**
+     * Gets ALL posts by automatically paginating through all pages
+     * Use this for static site generation to ensure all content is fetched
+     *
+     * @param filter - Filter options (status, categories, tags, author, search, etc.)
+     * @returns Array of all posts matching the filter criteria
+     */
+    getAllPosts(filter?: Omit<PostsFilter, "page">): Promise<WordPressPost[]>;
+    /**
+     * Gets posts with pagination metadata
+     *
+     * @param filter - Filter options including pagination (perPage, page)
+     * @returns Paginated response with posts and total counts
+     */
+    getPostsPaginated(filter?: PostsFilter): Promise<PaginatedResponse<WordPressPost>>;
+    /**
+     * Gets a single post by ID
+     */
+    getPost(id: number): Promise<WordPressPost>;
+    /**
+     * Gets a single post by slug
+     */
+    getPostBySlug(slug: string): Promise<WordPressPost | undefined>;
+};

package/dist/client/posts.js

@@ -0,0 +1,69 @@
+import { filterToParams } from './types';
+/**
+ * Posts API methods factory
+ * Creates type-safe methods for fetching WordPress posts with filtering and pagination
+ */
+export function createPostsMethods(fetchAPI, fetchAPIPaginated) {
+    return {
+        /**
+         * Gets posts with optional filtering (single page, max 100 items)
+         *
+         * @param filter - Filter options (status, categories, tags, author, search, etc.)
+         * @returns Array of posts matching the filter criteria
+         */
+        async getPosts(filter = {}) {
+            const params = filterToParams({ ...filter, _embed: 'true' });
+            return fetchAPI('/posts', params);
+        },
+        /**
+         * Gets ALL posts by automatically paginating through all pages
+         * Use this for static site generation to ensure all content is fetched
+         *
+         * @param filter - Filter options (status, categories, tags, author, search, etc.)
+         * @returns Array of all posts matching the filter criteria
+         */
+        async getAllPosts(filter = {}) {
+            const allPosts = [];
+            let page = 1;
+            let totalPages = 1;
+            do {
+                const params = filterToParams({ ...filter, page, perPage: 100, _embed: 'true' });
+                const result = await fetchAPIPaginated('/posts', params);
+                allPosts.push(...result.data);
+                totalPages = result.totalPages;
+                page++;
+            } while (page <= totalPages);
+            return allPosts;
+        },
+        /**
+         * Gets posts with pagination metadata
+         *
+         * @param filter - Filter options including pagination (perPage, page)
+         * @returns Paginated response with posts and total counts
+         */
+        async getPostsPaginated(filter = {}) {
+            const params = filterToParams({ ...filter, _embed: 'true' });
+            const result = await fetchAPIPaginated('/posts', params);
+            return {
+                data: result.data,
+                total: result.total,
+                totalPages: result.totalPages,
+                page: filter.page || 1,
+                perPage: filter.perPage || 100,
+            };
+        },
+        /**
+         * Gets a single post by ID
+         */
+        async getPost(id) {
+            return fetchAPI(`/posts/${id}`, { _embed: 'true' });
+        },
+        /**
+         * Gets a single post by slug
+         */
+        async getPostBySlug(slug) {
+            const posts = await fetchAPI('/posts', { slug, _embed: 'true' });
+            return posts[0];
+        },
+    };
+}

package/dist/client/settings.d.ts

@@ -0,0 +1,13 @@
+import type { WordPressSettings } from '../schemas';
+/**
+ * Settings API methods
+ */
+export declare function createSettingsMethods(fetchAPI: <T>(endpoint: string, params?: Record<string, string>) => Promise<T>, hasAuth: () => boolean): {
+    /**
+     * Gets WordPress site settings (requires authentication)
+     *
+     * @returns Site settings including title, description, URL, etc.
+     * @throws Error if authentication is not configured
+     */
+    getSettings(): Promise<WordPressSettings>;
+};

package/dist/client/settings.js

@@ -0,0 +1,19 @@
+/**
+ * Settings API methods
+ */
+export function createSettingsMethods(fetchAPI, hasAuth) {
+    return {
+        /**
+         * Gets WordPress site settings (requires authentication)
+         *
+         * @returns Site settings including title, description, URL, etc.
+         * @throws Error if authentication is not configured
+         */
+        async getSettings() {
+            if (!hasAuth()) {
+                throw new Error('Authentication required for /settings endpoint. Configure auth in client options.');
+            }
+            return fetchAPI('/settings');
+        },
+    };
+}

package/dist/client/tags.d.ts

@@ -0,0 +1,39 @@
+import type { WordPressTag } from '../schemas';
+import type { FetchResult } from './index';
+import type { TagsFilter, PaginatedResponse } from './types';
+/**
+ * Tags API methods factory
+ * Creates type-safe methods for fetching WordPress tags with filtering and pagination
+ */
+export declare function createTagsMethods(fetchAPI: <T>(endpoint: string, params?: Record<string, string>) => Promise<T>, fetchAPIPaginated: <T>(endpoint: string, params?: Record<string, string>) => Promise<FetchResult<T>>): {
+    /**
+     * Gets tags with optional filtering (single page, max 100 items)
+     *
+     * @param filter - Filter options (hideEmpty, include, exclude, search, etc.)
+     * @returns Array of tags matching the filter criteria
+     */
+    getTags(filter?: TagsFilter): Promise<WordPressTag[]>;
+    /**
+     * Gets ALL tags by automatically paginating through all pages
+     * Use this for static site generation to ensure all content is fetched
+     *
+     * @param filter - Filter options (hideEmpty, include, exclude, search, etc.)
+     * @returns Array of all tags matching the filter criteria
+     */
+    getAllTags(filter?: Omit<TagsFilter, "page">): Promise<WordPressTag[]>;
+    /**
+     * Gets tags with pagination metadata
+     *
+     * @param filter - Filter options including pagination (perPage, page)
+     * @returns Paginated response with tags and total counts
+     */
+    getTagsPaginated(filter?: TagsFilter): Promise<PaginatedResponse<WordPressTag>>;
+    /**
+     * Gets a single tag by ID
+     */
+    getTag(id: number): Promise<WordPressTag>;
+    /**
+     * Gets a single tag by slug
+     */
+    getTagBySlug(slug: string): Promise<WordPressTag | undefined>;
+};

package/dist/client/tags.js

@@ -0,0 +1,69 @@
+import { filterToParams } from './types';
+/**
+ * Tags API methods factory
+ * Creates type-safe methods for fetching WordPress tags with filtering and pagination
+ */
+export function createTagsMethods(fetchAPI, fetchAPIPaginated) {
+    return {
+        /**
+         * Gets tags with optional filtering (single page, max 100 items)
+         *
+         * @param filter - Filter options (hideEmpty, include, exclude, search, etc.)
+         * @returns Array of tags matching the filter criteria
+         */
+        async getTags(filter = {}) {
+            const params = filterToParams(filter);
+            return fetchAPI('/tags', params);
+        },
+        /**
+         * Gets ALL tags by automatically paginating through all pages
+         * Use this for static site generation to ensure all content is fetched
+         *
+         * @param filter - Filter options (hideEmpty, include, exclude, search, etc.)
+         * @returns Array of all tags matching the filter criteria
+         */
+        async getAllTags(filter = {}) {
+            const allTags = [];
+            let page = 1;
+            let totalPages = 1;
+            do {
+                const params = filterToParams({ ...filter, page, perPage: 100 });
+                const result = await fetchAPIPaginated('/tags', params);
+                allTags.push(...result.data);
+                totalPages = result.totalPages;
+                page++;
+            } while (page <= totalPages);
+            return allTags;
+        },
+        /**
+         * Gets tags with pagination metadata
+         *
+         * @param filter - Filter options including pagination (perPage, page)
+         * @returns Paginated response with tags and total counts
+         */
+        async getTagsPaginated(filter = {}) {
+            const params = filterToParams(filter);
+            const result = await fetchAPIPaginated('/tags', params);
+            return {
+                data: result.data,
+                total: result.total,
+                totalPages: result.totalPages,
+                page: filter.page || 1,
+                perPage: filter.perPage || 100,
+            };
+        },
+        /**
+         * Gets a single tag by ID
+         */
+        async getTag(id) {
+            return fetchAPI(`/tags/${id}`);
+        },
+        /**
+         * Gets a single tag by slug
+         */
+        async getTagBySlug(slug) {
+            const tags = await fetchAPI('/tags', { slug });
+            return tags[0];
+        },
+    };
+}