katanakit-js 6.4.3 → 6.6.1

package/dist/adapters/wordpress/wordpress.service.js

@@ -4,50 +4,6 @@ import { useValidate } from "../../core/services/validation.service.js";
 import { WordPressConfigSchema, WpBatchOperationSchema, WpBatchResultSchema, WpCategoryCreateSchema, WpCategoryListSchema, WpCategoryResponseSchema, WpCategoryUpdateSchema, WpCommentCreateSchema, WpCommentListSchema, WpCommentResponseSchema, WpCommentUpdateSchema, WpMediaListSchema, WpMediaMetaSchema, WpMediaResponseSchema, WpMediaUpdateSchema, WpPageCreateSchema, WpPageListSchema, WpPageResponseSchema, WpPageUpdateSchema, WpPostCreateSchema, WpPostListSchema, WpPostResponseSchema, WpPostUpdateSchema, WpTagCreateSchema, WpTagListSchema, WpTagResponseSchema, WpTagUpdateSchema, WpUserCreateSchema, WpUserListSchema, WpUserResponseSchema, WpUserUpdateSchema, } from "../../schemas/wordpress.schema.js";
 /** Default WordPress REST API namespace. */
 const WP_API_NAMESPACE = "wp/v2";
-/** Module-level WordPress configuration. */
-let config = null;
-/**
- * Retrieves the registered WordPress config or throws.
- * @internal
- */
-function getConfig() {
-    if (!config) {
-        throw new Error("[WordPress] Not configured. Call defineWordPressConfig() first.");
-    }
-    return config;
-}
-/**
- * Builds the base API URL from config.
- * @internal
- */
-function getApiBase() {
-    const { baseUrl, apiNamespace } = getConfig();
-    const ns = apiNamespace ?? WP_API_NAMESPACE;
-    const cleanBase = baseUrl.replace(/\/+$/, "");
-    return `${cleanBase}/wp-json/${ns}`;
-}
-/**
- * Builds authentication headers from config.
- * @internal
- */
-function getAuthHeaders() {
-    const { auth } = getConfig();
-    if (!auth)
-        return {};
-    switch (auth.type) {
-        case "application-passwords":
-        case "basic": {
-            const credentials = btoa(`${auth.username}:${auth.password}`);
-            return { Authorization: `Basic ${credentials}` };
-        }
-        case "jwt":
-            return { Authorization: `Bearer ${auth.token}` };
-        case "nonce":
-            return { "X-WP-Nonce": auth.nonce, Cookie: auth.cookie };
-        default:
-            return {};
-    }
-}
 /**
  * Converts query params to URL search params.
  * Handles _fields (string), _embed (boolean or string), and arrays.
@@ -116,115 +72,519 @@ function invalidInput(parsed) {
         ok: false,
     };
 }
-/**
- * Internal helper to make requests to the WordPress REST API.
- * @internal
- */
-async function wpFetch(endpoint, options = {}, schema) {
-    let url = "";
-    const attempt = await useAttempt(async () => {
-        url = `${getApiBase()}${endpoint}`;
-        const response = await fetch(url, {
-            ...options,
-            headers: {
-                "Content-Type": "application/json",
-                ...getAuthHeaders(),
-                ...options.headers,
-            },
-        });
-        if (!response.ok) {
-            const errorBody = await response.text().catch(() => null);
-            throw apiError(`WordPress API Error: ${response.statusText}`, response.status, errorBody);
-        }
-        if (response.status === 204) {
-            return { data: null, status: 204 };
-        }
-        const raw = (await response.json());
-        if (schema) {
-            const parsed = useValidate(schema, raw);
-            if (!parsed.ok) {
-                throw apiError("WordPress Validation Error: " + parsed.error.message, 502, parsed.error.details);
-            }
-            // WP may return partials via `_fields`, so the schema guarantees present fields are well-typed.
-            return { data: parsed.data, status: response.status };
-        }
-        return { data: raw, status: response.status };
-    });
-    if (!attempt.ok) {
-        const { message, status, details } = attempt.error;
-        return {
-            data: null,
-            error: { message: status === 0 ? `Network Error: ${message}` : message, status, details },
-            url,
-            status,
-            ok: false,
-        };
-    }
-    return { data: attempt.data.data, error: null, url, status: attempt.data.status, ok: true };
-}
 /** Builds a throwable error carrying `status`/`details` for `useAttempt`. */
 function apiError(message, status, details) {
     return Object.assign(new Error(message), { status, details });
 }
 /**
- * Internal helper for multipart file uploads.
- * @internal
+ * WordPressService - Singleton para el cliente del WordPress REST API.
+ *
+ * Aplica el patrón Singleton: una única instancia mantiene la configuración
+ * (URL base, auth, namespace) y centraliza todas las operaciones CRUD contra
+ * la REST API de WordPress, devolviendo siempre Safe Results.
+ *
+ * @example
+ * ```ts
+ * const wp = WordPressService.getInstance();
+ * wp.useInit({ baseUrl: "https://mysite.com", auth: { type: "jwt", token: "..." } });
+ * const result = await wp.useGetPosts({ per_page: 5 });
+ * ```
  */
-async function wpUpload(endpoint, file, meta, schema) {
-    let url = "";
-    const attempt = await useAttempt(async () => {
-        url = `${getApiBase()}${endpoint}`;
-        const formData = new FormData();
-        // Add the file
-        if (typeof Buffer !== "undefined" && file instanceof Buffer) {
-            const blob = new Blob([new Uint8Array(file)]);
-            formData.append("file", blob, "upload");
+export class WordPressService {
+    static instance;
+    /** Registered WordPress configuration. */
+    config = null;
+    /**
+     * Constructor privado - enforce singleton.
+     */
+    constructor() { }
+    /**
+     * Obtiene la instancia única del WordPressService (Singleton).
+     *
+     * @returns La instancia única de {@link WordPressService}.
+     */
+    static getInstance() {
+        if (!WordPressService.instance) {
+            WordPressService.instance = new WordPressService();
         }
-        else {
-            formData.append("file", file, file.name ?? "upload");
+        return WordPressService.instance;
+    }
+    /**
+     * Retrieves the registered WordPress config or throws.
+     * @internal
+     */
+    useGetConfig() {
+        if (!this.config) {
+            throw new Error("[WordPress] Not configured. Call defineWordPressConfig() first.");
+        }
+        return this.config;
+    }
+    /**
+     * Builds the base API URL from config.
+     * @internal
+     */
+    useGetApiBase() {
+        const { baseUrl, apiNamespace } = this.useGetConfig();
+        const ns = apiNamespace ?? WP_API_NAMESPACE;
+        const cleanBase = baseUrl.replace(/\/+$/, "");
+        return `${cleanBase}/wp-json/${ns}`;
+    }
+    /**
+     * Builds authentication headers from config.
+     * @internal
+     */
+    useGetAuthHeaders() {
+        const { auth } = this.useGetConfig();
+        if (!auth)
+            return {};
+        switch (auth.type) {
+            case "application-passwords":
+            case "basic": {
+                const credentials = btoa(`${auth.username}:${auth.password}`);
+                return { Authorization: `Basic ${credentials}` };
+            }
+            case "jwt":
+                return { Authorization: `Bearer ${auth.token}` };
+            case "nonce":
+                return { "X-WP-Nonce": auth.nonce, Cookie: auth.cookie };
+            default:
+                return {};
+        }
+    }
+    /**
+     * Internal helper to make requests to the WordPress REST API.
+     * @internal
+     */
+    async useRequest(endpoint, options = {}, schema) {
+        let url = "";
+        const attempt = await useAttempt(async () => {
+            url = `${this.useGetApiBase()}${endpoint}`;
+            const response = await fetch(url, {
+                ...options,
+                headers: {
+                    "Content-Type": "application/json",
+                    ...this.useGetAuthHeaders(),
+                    ...options.headers,
+                },
+            });
+            if (!response.ok) {
+                const errorBody = await response.text().catch(() => null);
+                throw apiError(`WordPress API Error: ${response.statusText}`, response.status, errorBody);
+            }
+            if (response.status === 204) {
+                return { data: null, status: 204 };
+            }
+            const raw = (await response.json());
+            if (schema) {
+                const parsed = useValidate(schema, raw);
+                if (!parsed.ok) {
+                    throw apiError("WordPress Validation Error: " + parsed.error.message, 502, parsed.error.details);
+                }
+                // WP may return partials via `_fields`, so the schema guarantees present fields are well-typed.
+                return { data: parsed.data, status: response.status };
+            }
+            return { data: raw, status: response.status };
+        });
+        if (!attempt.ok) {
+            const { message, status, details } = attempt.error;
+            return {
+                data: null,
+                error: {
+                    message: status === 0 ? `Network Error: ${message}` : message,
+                    status,
+                    details,
+                },
+                url,
+                status,
+                ok: false,
+            };
         }
-        // Add metadata
-        if (meta) {
-            for (const [key, value] of Object.entries(meta)) {
-                if (value !== undefined && value !== null) {
-                    formData.append(key, String(value));
+        return { data: attempt.data.data, error: null, url, status: attempt.data.status, ok: true };
+    }
+    /**
+     * Internal helper for multipart file uploads.
+     * @internal
+     */
+    async useUpload(endpoint, file, meta, schema) {
+        let url = "";
+        const attempt = await useAttempt(async () => {
+            url = `${this.useGetApiBase()}${endpoint}`;
+            const formData = new FormData();
+            // Add the file
+            if (typeof Buffer !== "undefined" && file instanceof Buffer) {
+                const blob = new Blob([new Uint8Array(file)]);
+                formData.append("file", blob, "upload");
+            }
+            else {
+                formData.append("file", file, file.name ?? "upload");
+            }
+            // Add metadata
+            if (meta) {
+                for (const [key, value] of Object.entries(meta)) {
+                    if (value !== undefined && value !== null) {
+                        formData.append(key, String(value));
+                    }
+                }
+            }
+            const response = await fetch(url, {
+                method: "POST",
+                headers: {
+                    ...this.useGetAuthHeaders(),
+                    // Don't set Content-Type — browser sets multipart boundary
+                },
+                body: formData,
+            });
+            if (!response.ok) {
+                const errorBody = await response.text().catch(() => null);
+                throw apiError(`WordPress Upload Error: ${response.statusText}`, response.status, errorBody);
+            }
+            const raw = (await response.json());
+            if (schema) {
+                const parsed = useValidate(schema, raw);
+                if (!parsed.ok) {
+                    throw apiError("WordPress Validation Error: " + parsed.error.message, 502, parsed.error.details);
                 }
+                return { data: parsed.data, status: response.status };
             }
+            return { data: raw, status: response.status };
+        });
+        if (!attempt.ok) {
+            const { message, status, details } = attempt.error;
+            return {
+                data: null,
+                error: { message: status === 0 ? `Upload Error: ${message}` : message, status, details },
+                url,
+                status,
+                ok: false,
+            };
+        }
+        return { data: attempt.data.data, error: null, url, status: attempt.data.status, ok: true };
+    }
+    /**
+     * Registers the WordPress REST API configuration.
+     *
+     * Supports multiple auth methods: Application Passwords, JWT tokens,
+     * Basic Auth, and nonce-based auth for themes.
+     *
+     * @param cfg - Site URL, authentication method, and optional API namespace.
+     * @throws {Error} If the config fails Zod validation.
+     *
+     * @example
+     * ```ts
+     * WordPressService.getInstance().useInit({
+     *   baseUrl: "https://mysite.com",
+     *   auth: { type: "application-passwords", username: "admin", password: "xxxx xxxx xxxx" },
+     * });
+     * ```
+     */
+    useInit(cfg) {
+        const parsed = useValidate(WordPressConfigSchema, cfg);
+        if (!parsed.ok) {
+            throw new Error("[WordPress] Invalid config: " + parsed.error.message);
         }
-        const response = await fetch(url, {
+        this.config = { ...parsed.data };
+    }
+    /* ---------------------------------------------------------------------- */
+    /* Posts                                                                    */
+    /* ---------------------------------------------------------------------- */
+    /** Retrieves a list of WordPress posts with optional filtering and pagination. */
+    async useGetPosts(options) {
+        return this.useRequest(`/posts${buildQueryParams(options)}`, {}, WpPostListSchema);
+    }
+    /** Retrieves a single WordPress post by ID. */
+    async useGetPost(id, options) {
+        return this.useRequest(`/posts/${id}${buildQueryParams(options)}`, {}, WpPostResponseSchema);
+    }
+    /** Creates a new WordPress post. */
+    async useCreatePost(data) {
+        const parsed = useValidate(WpPostCreateSchema, data);
+        if (!parsed.ok)
+            return invalidInput(parsed);
+        return this.useRequest("/posts", { method: "POST", body: JSON.stringify(data) }, WpPostResponseSchema);
+    }
+    /** Updates an existing WordPress post. */
+    async useUpdatePost(id, data) {
+        const parsed = useValidate(WpPostUpdateSchema, data);
+        if (!parsed.ok)
+            return invalidInput(parsed);
+        return this.useRequest(`/posts/${id}`, { method: "POST", body: JSON.stringify(data) }, WpPostResponseSchema);
+    }
+    /** Deletes a WordPress post (trash by default, permanent with `force`). */
+    async useDeletePost(id, force = false) {
+        return this.useRequest(`/posts/${id}?force=${force}`, { method: "DELETE" }, WpPostResponseSchema);
+    }
+    /* ---------------------------------------------------------------------- */
+    /* Pages                                                                    */
+    /* ---------------------------------------------------------------------- */
+    /** Retrieves a list of WordPress pages. */
+    async useGetPages(options) {
+        return this.useRequest(`/pages${buildQueryParams(options)}`, {}, WpPageListSchema);
+    }
+    /** Retrieves a single WordPress page by ID. */
+    async useGetPage(id, options) {
+        return this.useRequest(`/pages/${id}${buildQueryParams(options)}`, {}, WpPageResponseSchema);
+    }
+    /** Creates a new WordPress page. */
+    async useCreatePage(data) {
+        const parsed = useValidate(WpPageCreateSchema, data);
+        if (!parsed.ok)
+            return invalidInput(parsed);
+        return this.useRequest("/pages", { method: "POST", body: JSON.stringify(data) }, WpPageResponseSchema);
+    }
+    /** Updates an existing WordPress page. */
+    async useUpdatePage(id, data) {
+        const parsed = useValidate(WpPageUpdateSchema, data);
+        if (!parsed.ok)
+            return invalidInput(parsed);
+        return this.useRequest(`/pages/${id}`, { method: "POST", body: JSON.stringify(data) }, WpPageResponseSchema);
+    }
+    /** Deletes a WordPress page (trash by default, permanent with `force`). */
+    async useDeletePage(id, force = false) {
+        return this.useRequest(`/pages/${id}?force=${force}`, { method: "DELETE" }, WpPageResponseSchema);
+    }
+    /* ---------------------------------------------------------------------- */
+    /* Media                                                                    */
+    /* ---------------------------------------------------------------------- */
+    /** Retrieves a list of WordPress media items. */
+    async useGetMedia(options) {
+        return this.useRequest(`/media${buildQueryParams(options)}`, {}, WpMediaListSchema);
+    }
+    /** Retrieves a single WordPress media item by ID. */
+    async useGetMediaItem(id) {
+        return this.useRequest(`/media/${id}`, {}, WpMediaResponseSchema);
+    }
+    /** Uploads a file to the WordPress media library. */
+    async useUploadMedia(file, meta) {
+        if (meta !== undefined) {
+            const parsed = useValidate(WpMediaMetaSchema, meta);
+            if (!parsed.ok)
+                return invalidInput(parsed);
+        }
+        return this.useUpload("/media", file, meta, WpMediaResponseSchema);
+    }
+    /** Updates metadata of a WordPress media item. */
+    async useUpdateMedia(id, data) {
+        const parsed = useValidate(WpMediaUpdateSchema, data);
+        if (!parsed.ok)
+            return invalidInput(parsed);
+        return this.useRequest(`/media/${id}`, { method: "POST", body: JSON.stringify(data) }, WpMediaResponseSchema);
+    }
+    /** Deletes a WordPress media item. */
+    async useDeleteMedia(id, force = false) {
+        return this.useRequest(`/media/${id}?force=${force}`, { method: "DELETE" }, WpMediaResponseSchema);
+    }
+    /* ---------------------------------------------------------------------- */
+    /* Categories                                                               */
+    /* ---------------------------------------------------------------------- */
+    /** Retrieves a list of WordPress categories. */
+    async useGetCategories(options) {
+        return this.useRequest(`/categories${buildQueryParams(options)}`, {}, WpCategoryListSchema);
+    }
+    /** Retrieves a single WordPress category by ID. */
+    async useGetCategory(id) {
+        return this.useRequest(`/categories/${id}`, {}, WpCategoryResponseSchema);
+    }
+    /** Creates a new WordPress category. */
+    async useCreateCategory(data) {
+        const parsed = useValidate(WpCategoryCreateSchema, data);
+        if (!parsed.ok)
+            return invalidInput(parsed);
+        return this.useRequest("/categories", { method: "POST", body: JSON.stringify(data) }, WpCategoryResponseSchema);
+    }
+    /** Updates an existing WordPress category. */
+    async useUpdateCategory(id, data) {
+        const parsed = useValidate(WpCategoryUpdateSchema, data);
+        if (!parsed.ok)
+            return invalidInput(parsed);
+        return this.useRequest(`/categories/${id}`, { method: "POST", body: JSON.stringify(data) }, WpCategoryResponseSchema);
+    }
+    /** Deletes a WordPress category. */
+    async useDeleteCategory(id, force = false) {
+        return this.useRequest(`/categories/${id}?force=${force}`, { method: "DELETE" }, WpCategoryResponseSchema);
+    }
+    /* ---------------------------------------------------------------------- */
+    /* Tags                                                                     */
+    /* ---------------------------------------------------------------------- */
+    /** Retrieves a list of WordPress tags. */
+    async useGetTags(options) {
+        return this.useRequest(`/tags${buildQueryParams(options)}`, {}, WpTagListSchema);
+    }
+    /** Retrieves a single WordPress tag by ID. */
+    async useGetTag(id) {
+        return this.useRequest(`/tags/${id}`, {}, WpTagResponseSchema);
+    }
+    /** Creates a new WordPress tag. */
+    async useCreateTag(data) {
+        const parsed = useValidate(WpTagCreateSchema, data);
+        if (!parsed.ok)
+            return invalidInput(parsed);
+        return this.useRequest("/tags", { method: "POST", body: JSON.stringify(data) }, WpTagResponseSchema);
+    }
+    /** Updates an existing WordPress tag. */
+    async useUpdateTag(id, data) {
+        const parsed = useValidate(WpTagUpdateSchema, data);
+        if (!parsed.ok)
+            return invalidInput(parsed);
+        return this.useRequest(`/tags/${id}`, { method: "POST", body: JSON.stringify(data) }, WpTagResponseSchema);
+    }
+    /** Deletes a WordPress tag. */
+    async useDeleteTag(id, force = false) {
+        return this.useRequest(`/tags/${id}?force=${force}`, { method: "DELETE" }, WpTagResponseSchema);
+    }
+    /* ---------------------------------------------------------------------- */
+    /* Comments                                                                 */
+    /* ---------------------------------------------------------------------- */
+    /** Retrieves a list of WordPress comments. */
+    async useGetComments(options) {
+        return this.useRequest(`/comments${buildQueryParams(options)}`, {}, WpCommentListSchema);
+    }
+    /** Retrieves a single WordPress comment by ID. */
+    async useGetComment(id) {
+        return this.useRequest(`/comments/${id}`, {}, WpCommentResponseSchema);
+    }
+    /** Creates a new WordPress comment. */
+    async useCreateComment(data) {
+        const parsed = useValidate(WpCommentCreateSchema, data);
+        if (!parsed.ok)
+            return invalidInput(parsed);
+        return this.useRequest("/comments", { method: "POST", body: JSON.stringify(data) }, WpCommentResponseSchema);
+    }
+    /** Updates an existing WordPress comment. */
+    async useUpdateComment(id, data) {
+        const parsed = useValidate(WpCommentUpdateSchema, data);
+        if (!parsed.ok)
+            return invalidInput(parsed);
+        return this.useRequest(`/comments/${id}`, { method: "POST", body: JSON.stringify(data) }, WpCommentResponseSchema);
+    }
+    /** Deletes a WordPress comment. */
+    async useDeleteComment(id, force = false) {
+        return this.useRequest(`/comments/${id}?force=${force}`, { method: "DELETE" }, WpCommentResponseSchema);
+    }
+    /* ---------------------------------------------------------------------- */
+    /* Users                                                                    */
+    /* ---------------------------------------------------------------------- */
+    /** Retrieves a list of WordPress users. */
+    async useGetUsers(options) {
+        return this.useRequest(`/users${buildQueryParams(options)}`, {}, WpUserListSchema);
+    }
+    /** Retrieves a single WordPress user by ID. */
+    async useGetUser(id) {
+        return this.useRequest(`/users/${id}`, {}, WpUserResponseSchema);
+    }
+    /** Retrieves the currently authenticated WordPress user. */
+    async useGetCurrentUser() {
+        return this.useRequest("/users/me", {}, WpUserResponseSchema);
+    }
+    /** Creates a new WordPress user. */
+    async useCreateUser(data) {
+        const parsed = useValidate(WpUserCreateSchema, data);
+        if (!parsed.ok)
+            return invalidInput(parsed);
+        return this.useRequest("/users", { method: "POST", body: JSON.stringify(data) }, WpUserResponseSchema);
+    }
+    /** Updates an existing WordPress user. */
+    async useUpdateUser(id, data) {
+        const parsed = useValidate(WpUserUpdateSchema, data);
+        if (!parsed.ok)
+            return invalidInput(parsed);
+        return this.useRequest(`/users/${id}`, { method: "POST", body: JSON.stringify(data) }, WpUserResponseSchema);
+    }
+    /** Deletes a WordPress user, optionally reassigning their content. */
+    async useDeleteUser(id, reassign) {
+        const qs = reassign ? `?reassign=${reassign}` : "";
+        return this.useRequest(`/users/${id}${qs}`, { method: "DELETE" }, WpUserResponseSchema);
+    }
+    /* ---------------------------------------------------------------------- */
+    /* Custom Post Types                                                        */
+    /* ---------------------------------------------------------------------- */
+    /** Retrieves a list of custom post type entries. */
+    async useGetCustomPosts(postType, options) {
+        return this.useRequest(`/${postType}${buildQueryParams(options)}`);
+    }
+    /** Retrieves a single custom post type entry by ID. */
+    async useGetCustomPost(postType, id, options) {
+        return this.useRequest(`/${postType}/${id}${buildQueryParams(options)}`);
+    }
+    /** Creates a new custom post type entry. */
+    async useCreateCustomPost(postType, data) {
+        return this.useRequest(`/${postType}`, {
+            method: "POST",
+            body: JSON.stringify(data),
+        });
+    }
+    /** Updates a custom post type entry. */
+    async useUpdateCustomPost(postType, id, data) {
+        return this.useRequest(`/${postType}/${id}`, {
             method: "POST",
-            headers: {
-                ...getAuthHeaders(),
-                // Don't set Content-Type — browser sets multipart boundary
-            },
-            body: formData,
+            body: JSON.stringify(data),
+        });
+    }
+    /** Deletes a custom post type entry. */
+    async useDeleteCustomPost(postType, id, force = false) {
+        return this.useRequest(`/${postType}/${id}?force=${force}`, {
+            method: "DELETE",
         });
-        if (!response.ok) {
-            const errorBody = await response.text().catch(() => null);
-            throw apiError(`WordPress Upload Error: ${response.statusText}`, response.status, errorBody);
+    }
+    /* ---------------------------------------------------------------------- */
+    /* Batch Operations                                                         */
+    /* ---------------------------------------------------------------------- */
+    /** Executes multiple WordPress REST API requests in a single batch. */
+    async useBatch(operations) {
+        for (const operation of operations) {
+            const parsed = useValidate(WpBatchOperationSchema, operation);
+            if (!parsed.ok)
+                return invalidInput(parsed);
         }
-        const raw = (await response.json());
-        if (schema) {
-            const parsed = useValidate(schema, raw);
-            if (!parsed.ok) {
-                throw apiError("WordPress Validation Error: " + parsed.error.message, 502, parsed.error.details);
-            }
-            // WP may return partials via `_fields`, so the schema guarantees present fields are well-typed.
-            return { data: parsed.data, status: response.status };
+        return this.useRequest("/batch/v1", { method: "POST", body: JSON.stringify({ requests: operations }) }, WpBatchResultSchema);
+    }
+    /* ---------------------------------------------------------------------- */
+    /* Pagination Helpers                                                       */
+    /* ---------------------------------------------------------------------- */
+    /**
+     * Fetches ALL posts matching the criteria, automatically handling pagination.
+     *
+     * @param options - Query params for filtering. Do NOT pass `page` or `per_page`.
+     * @param maxItems - Cap on the total number of posts to fetch (default `1000`).
+     */
+    async useListAllPosts(options, maxItems = 1000) {
+        const allPosts = [];
+        let page = 1;
+        while (true) {
+            const result = await this.useGetPosts({ ...options, page, per_page: 100 });
+            if (!result.ok)
+                return result;
+            allPosts.push(...result.data);
+            if (maxItems && allPosts.length >= maxItems)
+                break;
+            if (result.data.length < 100)
+                break;
+            page++;
         }
-        return { data: raw, status: response.status };
-    });
-    if (!attempt.ok) {
-        const { message, status, details } = attempt.error;
         return {
-            data: null,
-            error: { message: status === 0 ? `Upload Error: ${message}` : message, status, details },
-            url,
-            status,
-            ok: false,
+            data: allPosts.slice(0, maxItems),
+            error: null,
+            url: "",
+            status: 200,
+            ok: true,
+        };
+    }
+    /** Searches ALL posts by keyword, automatically handling pagination. */
+    async useSearchAllPosts(query, options) {
+        return this.useListAllPosts({ ...options, search: query });
+    }
+    /** Finds a single post by its URL slug. Returns `null` if not found. */
+    async useFindPostBySlug(slug) {
+        const result = await this.useGetPosts({ slug, per_page: 1 });
+        if (!result.ok)
+            return result;
+        return {
+            data: result.data[0] ?? null,
+            error: null,
+            url: result.url,
+            status: result.status,
+            ok: true,
         };
     }
-    return { data: attempt.data.data, error: null, url, status: attempt.data.status, ok: true };
 }
 /* -------------------------------------------------------------------------- */
 /* Initialization                                                             */
@@ -280,53 +640,31 @@ export function defineWordPressConfig(input) {
  * ```ts
  * import { useInitWordPress } from "katanakit-js/adapters/wordpress";
  *
- * // With Application Passwords (recommended)
  * useInitWordPress({
  *   baseUrl: "https://mysite.com",
  *   auth: { type: "application-passwords", username: "admin", password: "xxxx xxxx xxxx" },
  * });
- *
- * // With JWT
- * useInitWordPress({
- *   baseUrl: "https://mysite.com",
- *   auth: { type: "jwt", token: "eyJhbGci..." },
- * });
  * ```
  */
 export function useInitWordPress(cfg) {
-    const parsed = useValidate(WordPressConfigSchema, cfg);
-    if (!parsed.ok) {
-        throw new Error("[WordPress] Invalid config: " + parsed.error.message);
-    }
-    config = { ...parsed.data };
+    WordPressService.getInstance().useInit(cfg);
 }
 /* -------------------------------------------------------------------------- */
-/* Posts                                                                      */
+/* Wrappers (backward compatibility)                                          */
 /* -------------------------------------------------------------------------- */
 /**
  * Retrieves a list of WordPress posts with optional filtering and pagination.
  *
- * Use to display blog listings, search posts, or filter by category/tag/status.
- * Returns a single page of results (default 10 per page).
- *
- * @param options - Query params: `per_page`, `page`, `search`, `categories`,
- *   `tags`, `status`, `orderby`, `order`, `_embed`, etc.
+ * @param options - Query params: `per_page`, `page`, `search`, `categories`, etc.
  * @returns Array of posts.
  *
  * @example
  * ```ts
- * // Get latest 5 published posts
  * const result = await useWpGetPosts({ per_page: 5, status: "publish" });
- *
- * // Search posts by keyword
- * const result = await useWpGetPosts({ search: "tutorial" });
- *
- * // Get posts from category 3, sorted by title
- * const result = await useWpGetPosts({ categories: 3, orderby: "title", order: "asc" });
  * ```
  */
 export async function useWpGetPosts(options) {
-    return wpFetch(`/posts${buildQueryParams(options)}`, {}, WpPostListSchema);
+    return WordPressService.getInstance().useGetPosts(options);
 }
 /**
  * Retrieves a single WordPress post by ID.
@@ -338,44 +676,24 @@ export async function useWpGetPosts(options) {
  * @example
  * ```ts
  * const result = await useWpGetPost(42, { _embed: true });
- * if (result.ok) console.log(result.data.title.rendered);
  * ```
  */
 export async function useWpGetPost(id, options) {
-    return wpFetch(`/posts/${id}${buildQueryParams(options)}`, {}, WpPostResponseSchema);
+    return WordPressService.getInstance().useGetPost(id, options);
 }
 /**
  * Creates a new WordPress post.
  *
- * Use to publish blog entries, create drafts, or schedule future posts.
- * The post will be assigned to the authenticated user by default.
- *
- * @param data - Post data: `title`, `content` (HTML), `status` (publish/draft/pending),
- *   `categories`, `tags`, `featured_media`, `excerpt`, `slug`, `date`, etc.
+ * @param data - Post data: `title`, `content`, `status`, `categories`, etc.
  * @returns The created post.
  *
  * @example
  * ```ts
- * // Publish immediately
- * const result = await useWpCreatePost({
- *   title: "My New Post",
- *   content: "<p>Hello World!</p>",
- *   status: "publish",
- *   categories: [1, 3],
- * });
- *
- * // Create as draft
- * await useWpCreatePost({ title: "Draft Post", content: "...", status: "draft" });
+ * const result = await useWpCreatePost({ title: "My New Post", content: "<p>Hello</p>", status: "publish" });
  * ```
  */
 export async function useWpCreatePost(data) {
-    const parsed = useValidate(WpPostCreateSchema, data);
-    if (!parsed.ok)
-        return invalidInput(parsed);
-    return wpFetch("/posts", {
-        method: "POST",
-        body: JSON.stringify(data),
-    }, WpPostResponseSchema);
+    return WordPressService.getInstance().useCreatePost(data);
 }
 /**
  * Updates an existing WordPress post.
@@ -390,13 +708,7 @@ export async function useWpCreatePost(data) {
  * ```
  */
 export async function useWpUpdatePost(id, data) {
-    const parsed = useValidate(WpPostUpdateSchema, data);
-    if (!parsed.ok)
-        return invalidInput(parsed);
-    return wpFetch(`/posts/${id}`, {
-        method: "POST",
-        body: JSON.stringify(data),
-    }, WpPostResponseSchema);
+    return WordPressService.getInstance().useUpdatePost(id, data);
 }
 /**
  * Deletes a WordPress post.
@@ -407,18 +719,12 @@ export async function useWpUpdatePost(id, data) {
  *
  * @example
  * ```ts
- * await useWpDeletePost(42); // Move to trash
- * await useWpDeletePost(42, true); // Permanently delete
+ * await useWpDeletePost(42, true);
  * ```
  */
 export async function useWpDeletePost(id, force = false) {
-    return wpFetch(`/posts/${id}?force=${force}`, {
-        method: "DELETE",
-    }, WpPostResponseSchema);
+    return WordPressService.getInstance().useDeletePost(id, force);
 }
-/* -------------------------------------------------------------------------- */
-/* Pages                                                                      */
-/* -------------------------------------------------------------------------- */
 /**
  * Retrieves a list of WordPress pages.
  *
@@ -431,7 +737,7 @@ export async function useWpDeletePost(id, force = false) {
  * ```
  */
 export async function useWpGetPages(options) {
-    return wpFetch(`/pages${buildQueryParams(options)}`, {}, WpPageListSchema);
+    return WordPressService.getInstance().useGetPages(options);
 }
 /**
  * Retrieves a single WordPress page by ID.
@@ -443,11 +749,10 @@ export async function useWpGetPages(options) {
  * @example
  * ```ts
  * const result = await useWpGetPage(10);
- * if (result.ok) console.log(result.data.title.rendered);
  * ```
  */
 export async function useWpGetPage(id, options) {
-    return wpFetch(`/pages/${id}${buildQueryParams(options)}`, {}, WpPageResponseSchema);
+    return WordPressService.getInstance().useGetPage(id, options);
 }
 /**
  * Creates a new WordPress page.
@@ -457,21 +762,11 @@ export async function useWpGetPage(id, options) {
  *
  * @example
  * ```ts
- * await useWpCreatePage({
- *   title: "About Us",
- *   content: "<p>Welcome to our site!</p>",
- *   status: "publish",
- * });
+ * await useWpCreatePage({ title: "About Us", content: "<p>Welcome</p>", status: "publish" });
  * ```
  */
 export async function useWpCreatePage(data) {
-    const parsed = useValidate(WpPageCreateSchema, data);
-    if (!parsed.ok)
-        return invalidInput(parsed);
-    return wpFetch("/pages", {
-        method: "POST",
-        body: JSON.stringify(data),
-    }, WpPageResponseSchema);
+    return WordPressService.getInstance().useCreatePage(data);
 }
 /**
  * Updates an existing WordPress page.
@@ -486,13 +781,7 @@ export async function useWpCreatePage(data) {
  * ```
  */
 export async function useWpUpdatePage(id, data) {
-    const parsed = useValidate(WpPageUpdateSchema, data);
-    if (!parsed.ok)
-        return invalidInput(parsed);
-    return wpFetch(`/pages/${id}`, {
-        method: "POST",
-        body: JSON.stringify(data),
-    }, WpPageResponseSchema);
+    return WordPressService.getInstance().useUpdatePage(id, data);
 }
 /**
  * Deletes a WordPress page.
@@ -503,17 +792,12 @@ export async function useWpUpdatePage(id, data) {
  *
  * @example
  * ```ts
- * await useWpDeletePage(10); // Move to trash
+ * await useWpDeletePage(10);
  * ```
  */
 export async function useWpDeletePage(id, force = false) {
-    return wpFetch(`/pages/${id}?force=${force}`, {
-        method: "DELETE",
-    }, WpPageResponseSchema);
+    return WordPressService.getInstance().useDeletePage(id, force);
 }
-/* -------------------------------------------------------------------------- */
-/* Media                                                                      */
-/* -------------------------------------------------------------------------- */
 /**
  * Retrieves a list of WordPress media items.
  *
@@ -526,7 +810,7 @@ export async function useWpDeletePage(id, force = false) {
  * ```
  */
 export async function useWpGetMedia(options) {
-    return wpFetch(`/media${buildQueryParams(options)}`, {}, WpMediaListSchema);
+    return WordPressService.getInstance().useGetMedia(options);
 }
 /**
  * Retrieves a single WordPress media item by ID.
@@ -537,45 +821,25 @@ export async function useWpGetMedia(options) {
  * @example
  * ```ts
  * const result = await useWpGetMediaItem(42);
- * if (result.ok) console.log(result.data.source_url);
  * ```
  */
 export async function useWpGetMediaItem(id) {
-    return wpFetch(`/media/${id}`, {}, WpMediaResponseSchema);
+    return WordPressService.getInstance().useGetMediaItem(id);
 }
 /**
  * Uploads a file to the WordPress media library.
  *
- * Use to upload images, documents, or any file type supported by WordPress.
- * Returns the media item with its URL for use as featured media or in content.
- *
  * @param file - File (browser), Blob, or Buffer (Node.js) to upload.
- * @param meta - Optional metadata: `title`, `alt_text`, `caption`, `description`,
- *   `post` (attach to existing post), `slug`.
+ * @param meta - Optional metadata: `title`, `alt_text`, `caption`, etc.
  * @returns The created media item with `source_url`.
  *
  * @example
  * ```ts
- * // From a file input (browser)
- * const file = document.querySelector("input[type=file]").files[0];
- * const result = await useWpUploadMedia(file, {
- *   title: "My Image",
- *   alt_text: "Description for accessibility",
- * });
- * if (result.ok) console.log(result.data.source_url); // URL to use in content
- *
- * // From a Buffer (Node.js)
- * const buffer = fs.readFileSync("photo.jpg");
- * await useWpUploadMedia(buffer, { title: "Photo" });
+ * const result = await useWpUploadMedia(file, { title: "My Image" });
  * ```
  */
 export async function useWpUploadMedia(file, meta) {
-    if (meta !== undefined) {
-        const parsed = useValidate(WpMediaMetaSchema, meta);
-        if (!parsed.ok)
-            return invalidInput(parsed);
-    }
-    return wpUpload("/media", file, meta, WpMediaResponseSchema);
+    return WordPressService.getInstance().useUploadMedia(file, meta);
 }
 /**
  * Updates metadata of a WordPress media item.
@@ -590,13 +854,7 @@ export async function useWpUploadMedia(file, meta) {
  * ```
  */
 export async function useWpUpdateMedia(id, data) {
-    const parsed = useValidate(WpMediaUpdateSchema, data);
-    if (!parsed.ok)
-        return invalidInput(parsed);
-    return wpFetch(`/media/${id}`, {
-        method: "POST",
-        body: JSON.stringify(data),
-    }, WpMediaResponseSchema);
+    return WordPressService.getInstance().useUpdateMedia(id, data);
 }
 /**
  * Deletes a WordPress media item.
@@ -611,13 +869,8 @@ export async function useWpUpdateMedia(id, data) {
  * ```
  */
 export async function useWpDeleteMedia(id, force = false) {
-    return wpFetch(`/media/${id}?force=${force}`, {
-        method: "DELETE",
-    }, WpMediaResponseSchema);
+    return WordPressService.getInstance().useDeleteMedia(id, force);
 }
-/* -------------------------------------------------------------------------- */
-/* Categories                                                                 */
-/* -------------------------------------------------------------------------- */
 /**
  * Retrieves a list of WordPress categories.
  *
@@ -627,11 +880,10 @@ export async function useWpDeleteMedia(id, force = false) {
  * @example
  * ```ts
  * const result = await useWpGetCategories({ per_page: 50 });
- * if (result.ok) result.data.forEach(c => console.log(c.name));
  * ```
  */
 export async function useWpGetCategories(options) {
-    return wpFetch(`/categories${buildQueryParams(options)}`, {}, WpCategoryListSchema);
+    return WordPressService.getInstance().useGetCategories(options);
 }
 /**
  * Retrieves a single WordPress category by ID.
@@ -642,11 +894,10 @@ export async function useWpGetCategories(options) {
  * @example
  * ```ts
  * const result = await useWpGetCategory(5);
- * if (result.ok) console.log(result.data.name);
  * ```
  */
 export async function useWpGetCategory(id) {
-    return wpFetch(`/categories/${id}`, {}, WpCategoryResponseSchema);
+    return WordPressService.getInstance().useGetCategory(id);
 }
 /**
  * Creates a new WordPress category.
@@ -660,13 +911,7 @@ export async function useWpGetCategory(id) {
  * ```
  */
 export async function useWpCreateCategory(data) {
-    const parsed = useValidate(WpCategoryCreateSchema, data);
-    if (!parsed.ok)
-        return invalidInput(parsed);
-    return wpFetch("/categories", {
-        method: "POST",
-        body: JSON.stringify(data),
-    }, WpCategoryResponseSchema);
+    return WordPressService.getInstance().useCreateCategory(data);
 }
 /**
  * Updates an existing WordPress category.
@@ -681,13 +926,7 @@ export async function useWpCreateCategory(data) {
  * ```
  */
 export async function useWpUpdateCategory(id, data) {
-    const parsed = useValidate(WpCategoryUpdateSchema, data);
-    if (!parsed.ok)
-        return invalidInput(parsed);
-    return wpFetch(`/categories/${id}`, {
-        method: "POST",
-        body: JSON.stringify(data),
-    }, WpCategoryResponseSchema);
+    return WordPressService.getInstance().useUpdateCategory(id, data);
 }
 /**
  * Deletes a WordPress category.
@@ -702,13 +941,8 @@ export async function useWpUpdateCategory(id, data) {
  * ```
  */
 export async function useWpDeleteCategory(id, force = false) {
-    return wpFetch(`/categories/${id}?force=${force}`, {
-        method: "DELETE",
-    }, WpCategoryResponseSchema);
+    return WordPressService.getInstance().useDeleteCategory(id, force);
 }
-/* -------------------------------------------------------------------------- */
-/* Tags                                                                       */
-/* -------------------------------------------------------------------------- */
 /**
  * Retrieves a list of WordPress tags.
  *
@@ -721,7 +955,7 @@ export async function useWpDeleteCategory(id, force = false) {
  * ```
  */
 export async function useWpGetTags(options) {
-    return wpFetch(`/tags${buildQueryParams(options)}`, {}, WpTagListSchema);
+    return WordPressService.getInstance().useGetTags(options);
 }
 /**
  * Retrieves a single WordPress tag by ID.
@@ -735,7 +969,7 @@ export async function useWpGetTags(options) {
  * ```
  */
 export async function useWpGetTag(id) {
-    return wpFetch(`/tags/${id}`, {}, WpTagResponseSchema);
+    return WordPressService.getInstance().useGetTag(id);
 }
 /**
  * Creates a new WordPress tag.
@@ -749,13 +983,7 @@ export async function useWpGetTag(id) {
  * ```
  */
 export async function useWpCreateTag(data) {
-    const parsed = useValidate(WpTagCreateSchema, data);
-    if (!parsed.ok)
-        return invalidInput(parsed);
-    return wpFetch("/tags", {
-        method: "POST",
-        body: JSON.stringify(data),
-    }, WpTagResponseSchema);
+    return WordPressService.getInstance().useCreateTag(data);
 }
 /**
  * Updates an existing WordPress tag.
@@ -770,13 +998,7 @@ export async function useWpCreateTag(data) {
  * ```
  */
 export async function useWpUpdateTag(id, data) {
-    const parsed = useValidate(WpTagUpdateSchema, data);
-    if (!parsed.ok)
-        return invalidInput(parsed);
-    return wpFetch(`/tags/${id}`, {
-        method: "POST",
-        body: JSON.stringify(data),
-    }, WpTagResponseSchema);
+    return WordPressService.getInstance().useUpdateTag(id, data);
 }
 /**
  * Deletes a WordPress tag.
@@ -791,13 +1013,8 @@ export async function useWpUpdateTag(id, data) {
  * ```
  */
 export async function useWpDeleteTag(id, force = false) {
-    return wpFetch(`/tags/${id}?force=${force}`, {
-        method: "DELETE",
-    }, WpTagResponseSchema);
+    return WordPressService.getInstance().useDeleteTag(id, force);
 }
-/* -------------------------------------------------------------------------- */
-/* Comments                                                                   */
-/* -------------------------------------------------------------------------- */
 /**
  * Retrieves a list of WordPress comments.
  *
@@ -806,12 +1023,11 @@ export async function useWpDeleteTag(id, force = false) {
  *
  * @example
  * ```ts
- * // Get comments for a specific post
  * const result = await useWpGetComments({ post: 42 });
  * ```
  */
 export async function useWpGetComments(options) {
-    return wpFetch(`/comments${buildQueryParams(options)}`, {}, WpCommentListSchema);
+    return WordPressService.getInstance().useGetComments(options);
 }
 /**
  * Retrieves a single WordPress comment by ID.
@@ -825,7 +1041,7 @@ export async function useWpGetComments(options) {
  * ```
  */
 export async function useWpGetComment(id) {
-    return wpFetch(`/comments/${id}`, {}, WpCommentResponseSchema);
+    return WordPressService.getInstance().useGetComment(id);
 }
 /**
  * Creates a new WordPress comment.
@@ -835,22 +1051,11 @@ export async function useWpGetComment(id) {
  *
  * @example
  * ```ts
- * await useWpCreateComment({
- *   post: 42,
- *   content: "Great article!",
- *   author_name: "John",
- *   author_email: "john@example.com",
- * });
+ * await useWpCreateComment({ post: 42, content: "Great article!" });
  * ```
  */
 export async function useWpCreateComment(data) {
-    const parsed = useValidate(WpCommentCreateSchema, data);
-    if (!parsed.ok)
-        return invalidInput(parsed);
-    return wpFetch("/comments", {
-        method: "POST",
-        body: JSON.stringify(data),
-    }, WpCommentResponseSchema);
+    return WordPressService.getInstance().useCreateComment(data);
 }
 /**
  * Updates an existing WordPress comment.
@@ -865,13 +1070,7 @@ export async function useWpCreateComment(data) {
  * ```
  */
 export async function useWpUpdateComment(id, data) {
-    const parsed = useValidate(WpCommentUpdateSchema, data);
-    if (!parsed.ok)
-        return invalidInput(parsed);
-    return wpFetch(`/comments/${id}`, {
-        method: "POST",
-        body: JSON.stringify(data),
-    }, WpCommentResponseSchema);
+    return WordPressService.getInstance().useUpdateComment(id, data);
 }
 /**
  * Deletes a WordPress comment.
@@ -886,13 +1085,8 @@ export async function useWpUpdateComment(id, data) {
  * ```
  */
 export async function useWpDeleteComment(id, force = false) {
-    return wpFetch(`/comments/${id}?force=${force}`, {
-        method: "DELETE",
-    }, WpCommentResponseSchema);
+    return WordPressService.getInstance().useDeleteComment(id, force);
 }
-/* -------------------------------------------------------------------------- */
-/* Users                                                                      */
-/* -------------------------------------------------------------------------- */
 /**
  * Retrieves a list of WordPress users.
  *
@@ -905,7 +1099,7 @@ export async function useWpDeleteComment(id, force = false) {
  * ```
  */
 export async function useWpGetUsers(options) {
-    return wpFetch(`/users${buildQueryParams(options)}`, {}, WpUserListSchema);
+    return WordPressService.getInstance().useGetUsers(options);
 }
 /**
  * Retrieves a single WordPress user by ID.
@@ -916,11 +1110,10 @@ export async function useWpGetUsers(options) {
  * @example
  * ```ts
  * const result = await useWpGetUser(1);
- * if (result.ok) console.log(result.data.name);
  * ```
  */
 export async function useWpGetUser(id) {
-    return wpFetch(`/users/${id}`, {}, WpUserResponseSchema);
+    return WordPressService.getInstance().useGetUser(id);
 }
 /**
  * Retrieves the currently authenticated WordPress user.
@@ -930,11 +1123,10 @@ export async function useWpGetUser(id) {
  * @example
  * ```ts
  * const result = await useWpGetCurrentUser();
- * if (result.ok) console.log(result.data.email);
  * ```
  */
 export async function useWpGetCurrentUser() {
-    return wpFetch("/users/me", {}, WpUserResponseSchema);
+    return WordPressService.getInstance().useGetCurrentUser();
 }
 /**
  * Creates a new WordPress user.
@@ -944,22 +1136,11 @@ export async function useWpGetCurrentUser() {
  *
  * @example
  * ```ts
- * await useWpCreateUser({
- *   username: "johndoe",
- *   email: "john@example.com",
- *   password: "secure-password",
- *   roles: ["editor"],
- * });
+ * await useWpCreateUser({ username: "johndoe", email: "john@example.com", password: "..." });
  * ```
  */
 export async function useWpCreateUser(data) {
-    const parsed = useValidate(WpUserCreateSchema, data);
-    if (!parsed.ok)
-        return invalidInput(parsed);
-    return wpFetch("/users", {
-        method: "POST",
-        body: JSON.stringify(data),
-    }, WpUserResponseSchema);
+    return WordPressService.getInstance().useCreateUser(data);
 }
 /**
  * Updates an existing WordPress user.
@@ -974,13 +1155,7 @@ export async function useWpCreateUser(data) {
  * ```
  */
 export async function useWpUpdateUser(id, data) {
-    const parsed = useValidate(WpUserUpdateSchema, data);
-    if (!parsed.ok)
-        return invalidInput(parsed);
-    return wpFetch(`/users/${id}`, {
-        method: "POST",
-        body: JSON.stringify(data),
-    }, WpUserResponseSchema);
+    return WordPressService.getInstance().useUpdateUser(id, data);
 }
 /**
  * Deletes a WordPress user.
@@ -991,18 +1166,12 @@ export async function useWpUpdateUser(id, data) {
  *
  * @example
  * ```ts
- * await useWpDeleteUser(2, 1); // Reassign content to user 1
+ * await useWpDeleteUser(2, 1);
  * ```
  */
 export async function useWpDeleteUser(id, reassign) {
-    const qs = reassign ? `?reassign=${reassign}` : "";
-    return wpFetch(`/users/${id}${qs}`, {
-        method: "DELETE",
-    }, WpUserResponseSchema);
+    return WordPressService.getInstance().useDeleteUser(id, reassign);
 }
-/* -------------------------------------------------------------------------- */
-/* Custom Post Types                                                          */
-/* -------------------------------------------------------------------------- */
 /**
  * Retrieves a list of custom post type entries.
  *
@@ -1016,7 +1185,7 @@ export async function useWpDeleteUser(id, reassign) {
  * ```
  */
 export async function useWpGetCustomPosts(postType, options) {
-    return wpFetch(`/${postType}${buildQueryParams(options)}`);
+    return WordPressService.getInstance().useGetCustomPosts(postType, options);
 }
 /**
  * Retrieves a single custom post type entry by ID.
@@ -1032,7 +1201,7 @@ export async function useWpGetCustomPosts(postType, options) {
  * ```
  */
 export async function useWpGetCustomPost(postType, id, options) {
-    return wpFetch(`/${postType}/${id}${buildQueryParams(options)}`);
+    return WordPressService.getInstance().useGetCustomPost(postType, id, options);
 }
 /**
  * Creates a new custom post type entry.
@@ -1043,18 +1212,11 @@ export async function useWpGetCustomPost(postType, id, options) {
  *
  * @example
  * ```ts
- * await useWpCreateCustomPost("product", {
- *   title: "Widget",
- *   content: "<p>A great widget</p>",
- *   status: "publish",
- * });
+ * await useWpCreateCustomPost("product", { title: "Widget", status: "publish" });
  * ```
  */
 export async function useWpCreateCustomPost(postType, data) {
-    return wpFetch(`/${postType}`, {
-        method: "POST",
-        body: JSON.stringify(data),
-    });
+    return WordPressService.getInstance().useCreateCustomPost(postType, data);
 }
 /**
  * Updates a custom post type entry.
@@ -1070,10 +1232,7 @@ export async function useWpCreateCustomPost(postType, data) {
  * ```
  */
 export async function useWpUpdateCustomPost(postType, id, data) {
-    return wpFetch(`/${postType}/${id}`, {
-        method: "POST",
-        body: JSON.stringify(data),
-    });
+    return WordPressService.getInstance().useUpdateCustomPost(postType, id, data);
 }
 /**
  * Deletes a custom post type entry.
@@ -1089,13 +1248,8 @@ export async function useWpUpdateCustomPost(postType, id, data) {
  * ```
  */
 export async function useWpDeleteCustomPost(postType, id, force = false) {
-    return wpFetch(`/${postType}/${id}?force=${force}`, {
-        method: "DELETE",
-    });
+    return WordPressService.getInstance().useDeleteCustomPost(postType, id, force);
 }
-/* -------------------------------------------------------------------------- */
-/* Batch Operations                                                           */
-/* -------------------------------------------------------------------------- */
 /**
  * Executes multiple WordPress REST API requests in a single batch.
  *
@@ -1106,75 +1260,30 @@ export async function useWpDeleteCustomPost(postType, id, force = false) {
  * ```ts
  * const result = await useWpBatch([
  *   { method: "GET", path: "/wp/v2/posts/1" },
- *   { method: "POST", path: "/wp/v2/posts", body: { title: "New Post" } },
  * ]);
- * if (result.ok) console.log(result.data.responses);
  * ```
  */
 export async function useWpBatch(operations) {
-    for (const operation of operations) {
-        const parsed = useValidate(WpBatchOperationSchema, operation);
-        if (!parsed.ok)
-            return invalidInput(parsed);
-    }
-    return wpFetch("/batch/v1", {
-        method: "POST",
-        body: JSON.stringify({ requests: operations }),
-    }, WpBatchResultSchema);
+    return WordPressService.getInstance().useBatch(operations);
 }
-/* -------------------------------------------------------------------------- */
-/* Pagination Helpers                                                         */
-/* -------------------------------------------------------------------------- */
 /**
  * Fetches ALL posts matching the criteria, automatically handling pagination.
  *
- * Use when you need every post (e.g. for sitemap generation, RSS feeds,
- * or data exports) without managing page numbers. Loops until all pages
- * are fetched.
- *
- * @param options - Query params for filtering (`status`, `categories`, `tags`,
- *   `author`, `search`, `orderby`, `order`). Do NOT pass `page` or `per_page`.
+ * @param options - Query params for filtering. Do NOT pass `page` or `per_page`.
  * @param maxItems - Cap on the total number of posts to fetch (default `1000`).
  * @returns All posts as a flat array.
  *
  * @example
  * ```ts
- * // Get ALL published posts
  * const result = await useWpListAllPosts({ status: "publish" });
- * if (result.ok) console.log(`Total: ${result.data.length}`);
- *
- * // Get ALL posts from category 5
- * const cat5 = await useWpListAllPosts({ categories: 5 });
  * ```
  */
 export async function useWpListAllPosts(options, maxItems = 1000) {
-    const allPosts = [];
-    let page = 1;
-    while (true) {
-        const result = await useWpGetPosts({ ...options, page, per_page: 100 });
-        if (!result.ok)
-            return result;
-        allPosts.push(...result.data);
-        if (maxItems && allPosts.length >= maxItems)
-            break;
-        if (result.data.length < 100)
-            break;
-        page++;
-    }
-    return {
-        data: allPosts.slice(0, maxItems),
-        error: null,
-        url: "",
-        status: 200,
-        ok: true,
-    };
+    return WordPressService.getInstance().useListAllPosts(options, maxItems);
 }
 /**
  * Searches ALL posts by keyword, automatically handling pagination.
  *
- * Use to find posts by title or content when you need every match,
- * not just the first page. Combines `search` param with auto-pagination.
- *
  * @param query - Search term (searches title and content).
  * @param options - Additional filters (`status`, `categories`, etc.).
  * @returns All posts matching the search.
@@ -1182,41 +1291,23 @@ export async function useWpListAllPosts(options, maxItems = 1000) {
  * @example
  * ```ts
  * const result = await useWpSearchAllPosts("tutorial");
- * if (result.ok) result.data.forEach(p => console.log(p.title.rendered));
  * ```
  */
 export async function useWpSearchAllPosts(query, options) {
-    return useWpListAllPosts({ ...options, search: query });
+    return WordPressService.getInstance().useSearchAllPosts(query, options);
 }
 /**
- * Finds a single post by its URL slug.
- *
- * Use for slug-based routing (e.g. `/blog/:slug` pages) where you need
- * to fetch a post by its human-readable URL identifier. Returns `null`
- * if no post matches the slug.
+ * Finds a single post by its URL slug. Returns `null` if not found.
  *
  * @param slug - The post slug (e.g. "hello-world").
  * @returns The post or `null` if not found.
  *
  * @example
  * ```ts
- * // In an Astro/[slug].astro or similar dynamic route
  * const result = await useWpFindPostBySlug("hello-world");
- * if (result.ok && result.data) {
- *   console.log(result.data.title.rendered);
- * }
  * ```
  */
 export async function useWpFindPostBySlug(slug) {
-    const result = await useWpGetPosts({ slug, per_page: 1 });
-    if (!result.ok)
-        return result;
-    return {
-        data: result.data[0] ?? null,
-        error: null,
-        url: result.url,
-        status: result.status,
-        ok: true,
-    };
+    return WordPressService.getInstance().useFindPostBySlug(slug);
 }
 //# sourceMappingURL=wordpress.service.js.map