@atomic-solutions/wordpress-api-client 0.1.0

package/dist/client/index.js

@@ -0,0 +1,1137 @@
+import axios, { isAxiosError } from 'axios';
+import { z } from 'zod';
+
+// src/client/createClient.ts
+
+// src/constants/endpoints.ts
+var ENDPOINTS = {
+  // Posts
+  POSTS: "/wp/v2/posts",
+  POST: (id) => `/wp/v2/posts/${id}`,
+  // Categories
+  CATEGORIES: "/wp/v2/categories",
+  CATEGORY: (id) => `/wp/v2/categories/${id}`,
+  // Tags
+  TAGS: "/wp/v2/tags",
+  TAG: (id) => `/wp/v2/tags/${id}`,
+  // Media
+  MEDIA: "/wp/v2/media",
+  MEDIA_ITEM: (id) => `/wp/v2/media/${id}`,
+  // Users
+  USERS: "/wp/v2/users",
+  USER: (id) => `/wp/v2/users/${id}`,
+  USERS_ME: "/wp/v2/users/me",
+  // JWT Auth (requires JWT Authentication plugin)
+  JWT_TOKEN: "/jwt-auth/v1/token",
+  JWT_VALIDATE: "/jwt-auth/v1/token/validate",
+  // Pages
+  PAGES: "/wp/v2/pages",
+  PAGE: (id) => `/wp/v2/pages/${id}`,
+  // Comments
+  COMMENTS: "/wp/v2/comments",
+  COMMENT: (id) => `/wp/v2/comments/${id}`,
+  // Search
+  SEARCH: "/wp/v2/search"
+};
+
+// src/errors/classes/BaseError.ts
+var BaseError = class extends Error {
+  constructor(options) {
+    super(options.message);
+    this.options = options;
+    Object.setPrototypeOf(this, new.target.prototype);
+    this.name = this.constructor.name;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+    if (this.options.cause instanceof Error && this.options.cause.stack) {
+      this.stack = `${this.stack}
+Caused by: ${this.options.cause.stack}`;
+    }
+  }
+  /**
+   * Get reportable data for error tracking/logging
+   * Subclasses should override this to add their own reportable fields
+   */
+  getReportableData() {
+    const { code, operation, userMessage, retryable } = this.options;
+    return {
+      code,
+      operation,
+      userMessage,
+      retryable
+    };
+  }
+  /**
+   * Custom JSON serialization
+   * Makes the error properly serializable for logging/reporting
+   */
+  toJSON() {
+    return {
+      ...this.getReportableData(),
+      name: this.name,
+      message: this.message,
+      stack: this.stack
+    };
+  }
+};
+
+// src/errors/mapping/auth.ts
+var AUTH_CODE_TRANSFORMATIONS = {
+  // Authentication
+  jwt_auth_failed: "auth_failed",
+  jwt_auth_invalid_token: "token_expired",
+  jwt_auth_bad_request: "invalid_auth_request",
+  // Authorization
+  rest_forbidden: "forbidden",
+  rest_cannot_read: "cannot_read",
+  rest_cannot_edit: "cannot_edit",
+  rest_cannot_create: "cannot_create",
+  rest_cannot_delete: "cannot_delete"
+};
+var AUTH_ERROR_METADATA = {
+  // Authentication
+  auth_failed: {
+    operation: "authenticate",
+    retryable: false,
+    userMessage: "Invalid username or password"
+  },
+  token_expired: {
+    operation: "validate_token",
+    retryable: false,
+    userMessage: "Your session has expired. Please sign in again."
+  },
+  invalid_auth_request: {
+    operation: "authenticate",
+    retryable: false,
+    userMessage: "Invalid login request"
+  },
+  // Authorization
+  forbidden: {
+    operation: "authorize",
+    retryable: false,
+    userMessage: "You do not have permission to access this resource"
+  },
+  cannot_read: {
+    operation: "read_resource",
+    retryable: false,
+    userMessage: "You do not have permission to view this content"
+  },
+  cannot_edit: {
+    operation: "edit_resource",
+    retryable: false,
+    userMessage: "You do not have permission to edit this content"
+  },
+  cannot_create: {
+    operation: "create_resource",
+    retryable: false,
+    userMessage: "You do not have permission to create content"
+  },
+  cannot_delete: {
+    operation: "delete_resource",
+    retryable: false,
+    userMessage: "You do not have permission to delete this content"
+  }
+};
+
+// src/errors/mapping/resources.ts
+var RESOURCE_CODE_TRANSFORMATIONS = {
+  rest_post_invalid_id: "post_not_found",
+  rest_term_invalid: "term_not_found",
+  rest_user_invalid_id: "user_not_found",
+  rest_no_route: "route_not_found"
+};
+var RESOURCE_ERROR_METADATA = {
+  post_not_found: {
+    operation: "get_post",
+    retryable: false,
+    userMessage: "Post not found"
+  },
+  term_not_found: {
+    operation: "get_term",
+    retryable: false,
+    userMessage: "Category or tag not found"
+  },
+  user_not_found: {
+    operation: "get_user",
+    retryable: false,
+    userMessage: "User not found"
+  },
+  route_not_found: {
+    operation: "api_request",
+    retryable: false,
+    userMessage: "The requested resource was not found"
+  }
+};
+
+// src/errors/mapping/server.ts
+var SERVER_CODE_TRANSFORMATIONS = {
+  rest_cookie_invalid_nonce: "invalid_nonce",
+  internal_error: "server_error"
+};
+var SERVER_ERROR_METADATA = {
+  invalid_nonce: {
+    operation: "api_request",
+    retryable: true,
+    userMessage: "Session expired. Please try again."
+  },
+  server_error: {
+    operation: "api_request",
+    retryable: true,
+    userMessage: "An unexpected error occurred. Please try again."
+  },
+  unknown_error: {
+    operation: "api_request",
+    retryable: false,
+    userMessage: "An error occurred"
+  }
+};
+
+// src/errors/mapping/constants.ts
+var VALIDATION_CODE_TRANSFORMATIONS = {
+  rest_invalid_param: "invalid_params",
+  rest_missing_callback_param: "missing_params"
+};
+var VALIDATION_ERROR_METADATA = {
+  invalid_params: {
+    operation: "api_request",
+    retryable: false,
+    userMessage: "Invalid request parameters"
+  },
+  missing_params: {
+    operation: "api_request",
+    retryable: false,
+    userMessage: "Missing required parameters"
+  }
+};
+var WORDPRESS_ERROR_METADATA = {
+  ...AUTH_ERROR_METADATA,
+  ...RESOURCE_ERROR_METADATA,
+  ...VALIDATION_ERROR_METADATA,
+  ...SERVER_ERROR_METADATA
+};
+
+// src/errors/mapping/index.ts
+var CODE_TRANSFORMATIONS = {
+  ...AUTH_CODE_TRANSFORMATIONS,
+  ...RESOURCE_CODE_TRANSFORMATIONS,
+  ...VALIDATION_CODE_TRANSFORMATIONS,
+  ...SERVER_CODE_TRANSFORMATIONS
+};
+var ERROR_METADATA = {
+  ...AUTH_ERROR_METADATA,
+  ...RESOURCE_ERROR_METADATA,
+  ...VALIDATION_ERROR_METADATA,
+  ...SERVER_ERROR_METADATA
+};
+var mapWordPressCode = (apiCode, status) => {
+  const appCode = CODE_TRANSFORMATIONS[apiCode];
+  if (appCode) {
+    const metadata = ERROR_METADATA[appCode];
+    return {
+      code: appCode,
+      ...metadata
+    };
+  }
+  if (apiCode.includes("invalid_id") || apiCode.includes("not_found")) {
+    return {
+      code: "route_not_found",
+      ...ERROR_METADATA.route_not_found
+    };
+  }
+  if (apiCode.includes("cannot_") || apiCode.includes("forbidden")) {
+    return {
+      code: "forbidden",
+      ...ERROR_METADATA.forbidden
+    };
+  }
+  if (apiCode.includes("invalid_param") || apiCode.includes("missing_")) {
+    return {
+      code: "invalid_params",
+      ...ERROR_METADATA.invalid_params
+    };
+  }
+  if (apiCode.includes("nonce")) {
+    return {
+      code: "invalid_nonce",
+      ...ERROR_METADATA.invalid_nonce
+    };
+  }
+  if (status === 401) {
+    return {
+      code: "auth_failed",
+      retryable: false,
+      userMessage: "Authentication required"
+    };
+  }
+  if (status === 403) {
+    return {
+      code: "forbidden",
+      ...ERROR_METADATA.forbidden
+    };
+  }
+  if (status === 404) {
+    return {
+      code: "route_not_found",
+      ...ERROR_METADATA.route_not_found
+    };
+  }
+  if (status >= 500) {
+    return {
+      code: "server_error",
+      ...ERROR_METADATA.server_error
+    };
+  }
+  return {
+    code: "unknown_error",
+    ...ERROR_METADATA.unknown_error
+  };
+};
+
+// src/errors/classes/WordPressApiError.ts
+var WordPressApiError = class extends BaseError {
+  constructor(options) {
+    const metadata = WORDPRESS_ERROR_METADATA[options.code] ?? {
+      operation: "wordpress_api_request",
+      retryable: false
+    };
+    const enrichedOptions = {
+      ...options,
+      operation: options.operation || metadata.operation,
+      userMessage: options.userMessage || metadata.userMessage,
+      retryable: options.retryable ?? metadata.retryable
+    };
+    super(enrichedOptions);
+  }
+  // Convenient getters for frequently accessed fields (no duplication)
+  get wpCode() {
+    return this.options.code;
+  }
+  get originalCode() {
+    return this.options.originalCode;
+  }
+  get statusCode() {
+    return this.options.statusCode;
+  }
+  get url() {
+    return this.options.url;
+  }
+  get method() {
+    return this.options.method;
+  }
+  get requestBody() {
+    return this.options.requestBody;
+  }
+  get responseBody() {
+    return this.options.responseBody;
+  }
+  get data() {
+    return this.options.data;
+  }
+  /**
+   * Check if error is an authentication error
+   */
+  get isAuthError() {
+    return this.statusCode === 401 || this.wpCode === "auth_failed" || this.wpCode === "token_expired" || this.wpCode === "invalid_auth_request";
+  }
+  /**
+   * Check if error is a not found error
+   */
+  get isNotFoundError() {
+    return this.statusCode === 404 || this.wpCode === "route_not_found" || this.wpCode === "post_not_found" || this.wpCode === "term_not_found" || this.wpCode === "user_not_found";
+  }
+  /**
+   * Get reportable data for error tracking/logging
+   * Includes HTTP context and WordPress-specific fields
+   */
+  getReportableData() {
+    return {
+      code: this.options.code,
+      operation: this.options.operation,
+      userMessage: this.options.userMessage,
+      retryable: this.options.retryable,
+      statusCode: this.options.statusCode,
+      url: this.options.url,
+      method: this.options.method,
+      wpCode: this.options.code,
+      originalCode: this.options.originalCode
+    };
+  }
+};
+
+// src/errors/classes/WordPressDataValidationError.ts
+var WordPressDataValidationError = class _WordPressDataValidationError extends BaseError {
+  constructor(options) {
+    const fieldErrors = options.zodError ? _WordPressDataValidationError.extractFieldErrorsFromZod(options.zodError) : void 0;
+    super({
+      code: "validation_error",
+      message: options.message,
+      operation: options.operation,
+      userMessage: options.userMessage || "Received unexpected data from WordPress",
+      retryable: false,
+      cause: options.cause,
+      url: options.url,
+      zodError: options.zodError,
+      value: options.value,
+      fieldErrors
+    });
+  }
+  // Convenient getters for validation-specific fields (no duplication)
+  get url() {
+    return this.options.url;
+  }
+  get zodError() {
+    return this.options.zodError;
+  }
+  get invalidValue() {
+    return this.options.value;
+  }
+  get fieldErrors() {
+    return this.options.fieldErrors;
+  }
+  /**
+   * Get reportable data for error tracking/logging
+   * Includes validation-specific fields
+   */
+  getReportableData() {
+    return {
+      code: this.options.code,
+      operation: this.options.operation,
+      userMessage: this.options.userMessage,
+      retryable: false,
+      fieldErrors: this.options.fieldErrors,
+      url: this.options.url
+    };
+  }
+  /**
+   * Extract field errors from Zod error
+   */
+  static extractFieldErrorsFromZod(zodError) {
+    if (!zodError?.errors) {
+      return void 0;
+    }
+    const fieldErrors = {};
+    for (const issue of zodError.errors) {
+      const path = issue.path.join(".");
+      if (!fieldErrors[path]) {
+        fieldErrors[path] = [];
+      }
+      fieldErrors[path].push(issue.message);
+    }
+    return fieldErrors;
+  }
+  /**
+   * Get all error messages as a flat array
+   */
+  getMessages() {
+    if (!this.fieldErrors) {
+      return [this.message];
+    }
+    const messages = [];
+    for (const fieldMessages of Object.values(this.fieldErrors)) {
+      messages.push(...fieldMessages);
+    }
+    return messages;
+  }
+  /**
+   * Check if a specific field has errors
+   */
+  hasFieldError(field) {
+    return this.fieldErrors ? field in this.fieldErrors : false;
+  }
+  /**
+   * Get error messages for a specific field
+   */
+  getFieldError(field) {
+    return this.fieldErrors?.[field];
+  }
+};
+
+// src/http/handleApiResponse.ts
+var handleApiResponse = (response, schema, options) => {
+  const validationMode = options?.validationMode ?? "strict";
+  if (validationMode === "warn") {
+    const result = schema.safeParse(response.data);
+    if (!result.success) {
+      const validationError = new WordPressDataValidationError({
+        message: `WordPress API response validation failed for ${response.config.url || "unknown endpoint"}`,
+        url: response.config.url,
+        zodError: result.error,
+        value: response.data,
+        userMessage: "Received unexpected data from WordPress"
+      });
+      options?.onValidationError?.(validationError);
+      options?.errorReporter?.(validationError);
+      console.warn("[wordpress-utils] Validation warning:", validationError.message);
+      return response.data;
+    }
+    return result.data;
+  }
+  try {
+    return schema.parse(response.data);
+  } catch (error2) {
+    if (error2 && typeof error2 === "object" && "issues" in error2) {
+      const validationError = new WordPressDataValidationError({
+        message: `WordPress API response validation failed for ${response.config.url || "unknown endpoint"}`,
+        url: response.config.url,
+        zodError: error2,
+        value: response.data,
+        userMessage: "Received unexpected data from WordPress"
+      });
+      options?.onValidationError?.(validationError);
+      options?.errorReporter?.(validationError);
+      throw validationError;
+    }
+    throw error2;
+  }
+};
+
+// src/utils/calculatePagination.ts
+var calculatePagination = (input) => {
+  const { page, perPage, total, totalPages } = input;
+  const hasNextPage = page < totalPages;
+  const hasPrevPage = page > 1;
+  return {
+    page,
+    perPage,
+    total,
+    totalPages,
+    hasNextPage,
+    hasPrevPage,
+    nextPage: hasNextPage ? page + 1 : null,
+    prevPage: hasPrevPage ? page - 1 : null
+  };
+};
+
+// src/utils/getPaginationMeta.ts
+var getPaginationMeta = (headers) => {
+  if (!headers) {
+    return {
+      total: 0,
+      totalPages: 0
+    };
+  }
+  const wpTotal = headers["x-wp-total"];
+  const wpTotalPages = headers["x-wp-totalpages"];
+  if (!wpTotal || !wpTotalPages) {
+    return {
+      total: 0,
+      totalPages: 0
+    };
+  }
+  const total = parseInt(wpTotal, 10);
+  const totalPages = parseInt(wpTotalPages, 10);
+  return {
+    total,
+    totalPages
+  };
+};
+
+// src/http/handlePaginatedApiResponse.ts
+var handlePaginatedApiResponse = (response, schema, params = {}, options) => {
+  const validationMode = options?.validationMode ?? "strict";
+  let data;
+  if (validationMode === "warn") {
+    const result = schema.safeParse(response.data);
+    if (!result.success) {
+      const validationError = new WordPressDataValidationError({
+        message: `WordPress API response validation failed for ${response.config.url || "unknown endpoint"}`,
+        url: response.config.url,
+        zodError: result.error,
+        value: response.data,
+        userMessage: "Received unexpected data from WordPress"
+      });
+      options?.onValidationError?.(validationError);
+      options?.errorReporter?.(validationError);
+      console.warn("[wordpress-utils] Validation warning:", validationError.message);
+      data = Array.isArray(response.data) ? response.data : [];
+    } else {
+      data = result.data;
+    }
+  } else {
+    try {
+      data = schema.parse(response.data);
+    } catch (error2) {
+      if (error2 && typeof error2 === "object" && "issues" in error2) {
+        const validationError = new WordPressDataValidationError({
+          message: `WordPress API response validation failed for ${response.config.url || "unknown endpoint"}`,
+          url: response.config.url,
+          zodError: error2,
+          value: response.data,
+          userMessage: "Received unexpected data from WordPress"
+        });
+        options?.onValidationError?.(validationError);
+        options?.errorReporter?.(validationError);
+        throw validationError;
+      }
+      throw error2;
+    }
+  }
+  const { total, totalPages } = getPaginationMeta(response.headers);
+  const page = params.page || 1;
+  const perPage = params.per_page || 10;
+  const pagination = calculatePagination({
+    page,
+    perPage,
+    total,
+    totalPages
+  });
+  return {
+    data,
+    pagination
+  };
+};
+
+// src/logging/logger.ts
+var DEBUG_PREFIX = "[wordpress-utils]";
+var isDebugEnabled = () => {
+  if (typeof process !== "undefined" && process.env) {
+    return process.env.DEBUG === "true" || process.env.DEBUG === "1";
+  }
+  return false;
+};
+var debug = (...args) => {
+  if (isDebugEnabled()) {
+    console.log(DEBUG_PREFIX, ...args);
+  }
+};
+var error = (...args) => {
+  console.error(DEBUG_PREFIX, ...args);
+};
+
+// src/http/interceptors/request.ts
+var setupRequestInterceptor = (axiosInstance, config, client) => {
+  axiosInstance.interceptors.request.use(
+    async (requestConfig) => {
+      if (config.jwtToken) {
+        const token = await config.jwtToken.get();
+        if (token) {
+          requestConfig.headers.Authorization = `Bearer ${token}`;
+          debug("JWT token injected");
+        }
+      }
+      if (config.onRequest) {
+        return config.onRequest(requestConfig, client);
+      }
+      return requestConfig;
+    },
+    (error2) => {
+      return Promise.reject(error2);
+    }
+  );
+};
+
+// src/http/interceptors/response.ts
+var setupResponseInterceptor = (axiosInstance, config, client) => {
+  axiosInstance.interceptors.response.use(
+    async (response) => {
+      debug("Response:", response.config.url, response.status);
+      if (config.onResponse) {
+        return config.onResponse(response, client);
+      }
+      return response;
+    },
+    (error2) => {
+      return Promise.reject(error2);
+    }
+  );
+};
+var setupErrorInterceptor = (axiosInstance, config, client) => {
+  axiosInstance.interceptors.response.use(
+    (response) => response,
+    async (axiosError) => {
+      const status = axiosError.response?.status || 500;
+      const errorData = axiosError.response?.data;
+      const apiCode = errorData?.code || "unknown_error";
+      const wpMessage = errorData?.message || axiosError.message || "Unknown error";
+      const mappedError = mapWordPressCode(apiCode, status);
+      const wpError = new WordPressApiError({
+        message: wpMessage,
+        statusCode: status,
+        code: mappedError.code,
+        // Transformed app-level code
+        originalCode: apiCode,
+        // Original WordPress API code
+        retryable: mappedError.retryable,
+        userMessage: mappedError.userMessage,
+        operation: axiosError.config?.url || "wordpress_api_request",
+        url: axiosError.config?.url || "",
+        method: axiosError.config?.method?.toUpperCase() || "GET",
+        requestBody: axiosError.config?.data,
+        responseBody: errorData,
+        cause: axiosError
+      });
+      if (config.debug) {
+        debug("WordPress error:", apiCode, status, wpMessage);
+        error(wpError);
+      }
+      if ((status === 401 || status === 403) && config.onAuthError && isAxiosError(axiosError) && !axiosError.config?._retry) {
+        if (config.debug) {
+          debug("Auth error detected, calling onAuthError handler");
+        }
+        try {
+          const shouldRetry = await config.onAuthError(wpError, client);
+          if (shouldRetry) {
+            if (config.debug) {
+              debug("Retrying request after auth error");
+            }
+            axiosError.config._retry = true;
+            return axiosInstance.request(axiosError.config);
+          }
+        } catch (authErrorHandlerError) {
+          if (config.debug) {
+            debug("onAuthError handler threw error", authErrorHandlerError);
+          }
+        }
+      }
+      if (config.onError) {
+        config.onError(wpError, client);
+      }
+      config.errorReporter?.report(wpError);
+      return Promise.reject(wpError);
+    }
+  );
+};
+var paginationParamsSchema = z.object({
+  /** Current page number */
+  page: z.number().int().positive().optional(),
+  /** Items per page */
+  per_page: z.number().int().positive().max(100).optional(),
+  /** Offset for pagination */
+  offset: z.number().int().nonnegative().optional(),
+  /** Sort order */
+  order: z.enum(["asc", "desc"]).optional(),
+  /** Field to sort by */
+  orderby: z.string().optional()
+});
+z.object({
+  /** Total number of items */
+  total: z.number(),
+  /** Total number of pages */
+  totalPages: z.number(),
+  /** Current page */
+  currentPage: z.number(),
+  /** Items per page */
+  perPage: z.number()
+});
+z.object({
+  username: z.string(),
+  password: z.string()
+});
+var JwtTokenResponseSchema = z.object({
+  token: z.string(),
+  user_email: z.string(),
+  user_nicename: z.string(),
+  user_display_name: z.string()
+});
+z.object({
+  code: z.string(),
+  data: z.object({
+    status: z.number()
+  })
+});
+z.object({
+  code: z.string(),
+  message: z.string(),
+  data: z.object({
+    status: z.number()
+  }).optional()
+});
+var RenderedContentSchema = z.object({
+  rendered: z.string(),
+  protected: z.boolean().optional()
+});
+var GuidSchema = z.object({
+  rendered: z.string()
+});
+z.enum([
+  "publish",
+  "future",
+  "draft",
+  "pending",
+  "private",
+  "trash",
+  "auto-draft",
+  "inherit"
+]);
+var HalLinkItemSchema = z.object({
+  href: z.string(),
+  embeddable: z.boolean().optional(),
+  templated: z.boolean().optional()
+});
+var HalLinksSchema = z.object({
+  self: z.array(HalLinkItemSchema).optional(),
+  collection: z.array(HalLinkItemSchema).optional(),
+  about: z.array(HalLinkItemSchema).optional(),
+  author: z.array(HalLinkItemSchema).optional(),
+  replies: z.array(HalLinkItemSchema).optional(),
+  "wp:featuredmedia": z.array(HalLinkItemSchema).optional(),
+  "wp:attachment": z.array(HalLinkItemSchema).optional(),
+  "wp:term": z.array(HalLinkItemSchema).optional(),
+  "wp:post_type": z.array(HalLinkItemSchema).optional(),
+  curies: z.array(
+    z.object({
+      name: z.string(),
+      href: z.string(),
+      templated: z.boolean()
+    })
+  ).optional()
+}).passthrough();
+z.object({
+  id: z.number(),
+  date: z.string(),
+  date_gmt: z.string(),
+  modified: z.string(),
+  modified_gmt: z.string(),
+  slug: z.string(),
+  status: z.string(),
+  type: z.string(),
+  link: z.string(),
+  _links: HalLinksSchema.optional()
+});
+var CategorySchema = z.object({
+  id: z.number(),
+  count: z.number(),
+  description: z.string().optional(),
+  link: z.string(),
+  name: z.string(),
+  slug: z.string(),
+  taxonomy: z.string(),
+  parent: z.number(),
+  meta: z.any().optional(),
+  _links: HalLinksSchema.optional()
+});
+var CategoriesListSchema = z.array(CategorySchema);
+paginationParamsSchema.extend({
+  context: z.enum(["view", "embed", "edit"]).optional(),
+  search: z.string().optional(),
+  exclude: z.array(z.number()).optional(),
+  include: z.array(z.number()).optional(),
+  hide_empty: z.boolean().optional(),
+  parent: z.number().optional(),
+  post: z.number().optional(),
+  slug: z.string().optional()
+});
+var TagSchema = z.object({
+  id: z.number(),
+  count: z.number(),
+  description: z.string().optional(),
+  link: z.string(),
+  name: z.string(),
+  slug: z.string(),
+  taxonomy: z.string(),
+  meta: z.any().optional(),
+  _links: HalLinksSchema.optional()
+});
+z.array(TagSchema);
+var MediaSizeSchema = z.object({
+  file: z.string(),
+  width: z.number(),
+  height: z.number(),
+  filesize: z.number().optional(),
+  mime_type: z.string(),
+  source_url: z.string()
+});
+var MediaSizesSchema = z.object({
+  thumbnail: MediaSizeSchema.optional(),
+  medium: MediaSizeSchema.optional(),
+  medium_large: MediaSizeSchema.optional(),
+  large: MediaSizeSchema.optional(),
+  full: MediaSizeSchema.optional()
+}).passthrough();
+var ImageMetaSchema = z.object({
+  aperture: z.string().optional(),
+  credit: z.string().optional(),
+  camera: z.string().optional(),
+  caption: z.string().optional(),
+  created_timestamp: z.string().optional(),
+  copyright: z.string().optional(),
+  focal_length: z.string().optional(),
+  iso: z.string().optional(),
+  shutter_speed: z.string().optional(),
+  title: z.string().optional(),
+  orientation: z.string().optional(),
+  keywords: z.array(z.string()).optional()
+});
+var MediaDetailsSchema = z.object({
+  width: z.number(),
+  height: z.number(),
+  file: z.string(),
+  filesize: z.number().optional(),
+  sizes: MediaSizesSchema,
+  image_meta: ImageMetaSchema.optional()
+});
+var MediaSchema = z.object({
+  id: z.number(),
+  date: z.string(),
+  date_gmt: z.string(),
+  guid: GuidSchema,
+  modified: z.string(),
+  modified_gmt: z.string(),
+  slug: z.string(),
+  status: z.string(),
+  type: z.string(),
+  link: z.string(),
+  title: RenderedContentSchema,
+  author: z.number(),
+  comment_status: z.string(),
+  ping_status: z.string(),
+  template: z.string().optional(),
+  meta: z.any().optional(),
+  description: RenderedContentSchema,
+  caption: RenderedContentSchema,
+  alt_text: z.string(),
+  media_type: z.string(),
+  mime_type: z.string(),
+  media_details: MediaDetailsSchema,
+  post: z.number().nullable(),
+  source_url: z.string(),
+  _links: HalLinksSchema.optional()
+});
+z.array(MediaSchema);
+var PostSchema = z.object({
+  id: z.number(),
+  date: z.string(),
+  date_gmt: z.string(),
+  guid: GuidSchema,
+  modified: z.string(),
+  modified_gmt: z.string(),
+  slug: z.string(),
+  status: z.string(),
+  type: z.string(),
+  link: z.string(),
+  title: RenderedContentSchema,
+  content: RenderedContentSchema,
+  excerpt: RenderedContentSchema,
+  author: z.number(),
+  featured_media: z.number(),
+  comment_status: z.string(),
+  ping_status: z.string(),
+  sticky: z.boolean(),
+  template: z.string(),
+  format: z.string(),
+  meta: z.any().optional(),
+  categories: z.array(z.number()),
+  tags: z.array(z.number()).optional(),
+  _links: HalLinksSchema.optional()
+});
+var PostsListSchema = z.array(PostSchema);
+paginationParamsSchema.extend({
+  context: z.enum(["view", "embed", "edit"]).optional(),
+  search: z.string().optional(),
+  after: z.string().optional(),
+  before: z.string().optional(),
+  author: z.union([z.number(), z.array(z.number())]).optional(),
+  author_exclude: z.array(z.number()).optional(),
+  exclude: z.array(z.number()).optional(),
+  include: z.array(z.number()).optional(),
+  categories: z.union([z.number(), z.array(z.number())]).optional(),
+  categories_exclude: z.array(z.number()).optional(),
+  tags: z.union([z.number(), z.array(z.number())]).optional(),
+  tags_exclude: z.array(z.number()).optional(),
+  sticky: z.boolean().optional()
+});
+var EmbeddedPostSchema = z.object({
+  id: z.number(),
+  title: z.string(),
+  content: z.string(),
+  featured_image: z.string().optional(),
+  published_date: z.string(),
+  categories: z.array(
+    z.object({
+      id: z.number(),
+      name: z.string(),
+      slug: z.string(),
+      taxonomy: z.string().optional(),
+      description: z.string().optional(),
+      parent: z.number().optional(),
+      count: z.number().optional()
+    })
+  ).optional()
+});
+z.array(EmbeddedPostSchema);
+var AvatarUrlsSchema = z.object({
+  "24": z.string().optional(),
+  "48": z.string().optional(),
+  "96": z.string().optional()
+});
+var UserSchema = z.object({
+  id: z.number(),
+  username: z.string().optional(),
+  // Only in edit context
+  name: z.string(),
+  first_name: z.string().optional(),
+  last_name: z.string().optional(),
+  email: z.string().optional(),
+  // Only for current user or admin
+  url: z.string(),
+  description: z.string(),
+  link: z.string(),
+  locale: z.string().optional(),
+  // Only for current user
+  nickname: z.string().optional(),
+  // Only in edit context
+  slug: z.string(),
+  registered_date: z.string().optional(),
+  // Only in edit context
+  roles: z.array(z.string()).optional(),
+  // Only in edit context
+  capabilities: z.record(z.boolean()).optional(),
+  // Only in edit context
+  extra_capabilities: z.record(z.boolean()).optional(),
+  // Only in edit context
+  avatar_urls: AvatarUrlsSchema.optional(),
+  meta: z.any().optional(),
+  _links: HalLinksSchema.optional()
+});
+z.array(UserSchema);
+var CurrentUserSchema = UserSchema.extend({
+  username: z.string(),
+  email: z.string(),
+  locale: z.string(),
+  nickname: z.string(),
+  registered_date: z.string(),
+  roles: z.array(z.string())
+});
+
+// src/api/auth.ts
+var createAuthAPI = (axios2, options) => ({
+  /**
+   * Login with username/password and get JWT token
+   */
+  async login(input) {
+    const response = await axios2.post(ENDPOINTS.JWT_TOKEN, input);
+    return handleApiResponse(response, JwtTokenResponseSchema, options);
+  },
+  /**
+   * Validate current JWT token
+   *
+   * Requires Authorization header to be set
+   */
+  async validateToken() {
+    try {
+      const response = await axios2.post(ENDPOINTS.JWT_VALIDATE);
+      return response.data?.code === "jwt_auth_valid_token";
+    } catch {
+      return false;
+    }
+  }
+});
+
+// src/api/categories.ts
+var createCategoriesAPI = (axios2, options) => ({
+  /**
+   * Get list of categories with pagination
+   */
+  async list(params) {
+    const response = await axios2.get(ENDPOINTS.CATEGORIES, { params });
+    return handlePaginatedApiResponse(response, CategoriesListSchema, params, options);
+  },
+  /**
+   * Get single category by ID
+   */
+  async get(id) {
+    const response = await axios2.get(ENDPOINTS.CATEGORY(id));
+    return handleApiResponse(response, CategorySchema, options);
+  }
+});
+
+// src/api/media.ts
+var createMediaAPI = (axios2, options) => ({
+  /**
+   * Get single media item by ID
+   */
+  async get(id) {
+    const response = await axios2.get(ENDPOINTS.MEDIA_ITEM(id));
+    return handleApiResponse(response, MediaSchema, options);
+  }
+});
+
+// src/api/posts.ts
+var createPostsAPI = (axios2, options) => ({
+  /**
+   * Get list of posts with pagination
+   */
+  async list(params) {
+    const response = await axios2.get(ENDPOINTS.POSTS, { params });
+    return handlePaginatedApiResponse(response, PostsListSchema, params, options);
+  },
+  /**
+   * Get single post by ID
+   */
+  async get(id) {
+    const response = await axios2.get(ENDPOINTS.POST(id));
+    return handleApiResponse(response, PostSchema, options);
+  },
+  /**
+   * Get single post by slug
+   */
+  async getBySlug(slug) {
+    const response = await axios2.get(ENDPOINTS.POSTS, {
+      params: { slug, per_page: 1 }
+    });
+    const posts = handleApiResponse(response, PostsListSchema, options);
+    return posts[0] || null;
+  }
+});
+
+// src/api/users.ts
+var createUsersAPI = (axios2, options) => ({
+  /**
+   * Get current authenticated user
+   */
+  async me() {
+    const response = await axios2.get(ENDPOINTS.USERS_ME);
+    return handleApiResponse(response, CurrentUserSchema, options);
+  },
+  /**
+   * Get user by ID
+   */
+  async get(id) {
+    const response = await axios2.get(ENDPOINTS.USER(id));
+    return handleApiResponse(response, UserSchema, options);
+  }
+});
+
+// src/client/createClient.ts
+var DEFAULT_ERROR_REPORTER = {
+  report: (error2) => {
+    console.error("[wordpress-utils]", error2);
+  }
+};
+var createClient = (config) => {
+  const fullConfig = {
+    ...config,
+    errorReporter: config.errorReporter ?? DEFAULT_ERROR_REPORTER
+  };
+  const axiosInstance = axios.create({
+    baseURL: fullConfig.baseURL,
+    timeout: fullConfig.timeout || 3e4,
+    headers: {
+      "Content-Type": "application/json",
+      ...fullConfig.headers
+    }
+  });
+  const responseOptions = {
+    errorReporter: fullConfig.errorReporter?.report,
+    onValidationError: fullConfig.onValidationError,
+    validationMode: fullConfig.validationMode
+  };
+  const client = {
+    config: fullConfig,
+    axios: axiosInstance,
+    posts: createPostsAPI(axiosInstance, responseOptions),
+    categories: createCategoriesAPI(axiosInstance, responseOptions),
+    media: createMediaAPI(axiosInstance, responseOptions),
+    users: createUsersAPI(axiosInstance, responseOptions),
+    auth: createAuthAPI(axiosInstance, responseOptions)
+  };
+  setupRequestInterceptor(axiosInstance, fullConfig, client);
+  setupResponseInterceptor(axiosInstance, fullConfig, client);
+  setupErrorInterceptor(axiosInstance, fullConfig, client);
+  return client;
+};
+
+export { createClient };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map