@atomic-solutions/wordpress-api-client 0.1.0

package/dist/testing/index.cjs

@@ -0,0 +1,1435 @@
+'use strict';
+
+var axios = require('axios');
+var zod = require('zod');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var axios__default = /*#__PURE__*/_interopDefault(axios);
+
+// 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 && axios.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 = zod.z.object({
+  /** Current page number */
+  page: zod.z.number().int().positive().optional(),
+  /** Items per page */
+  per_page: zod.z.number().int().positive().max(100).optional(),
+  /** Offset for pagination */
+  offset: zod.z.number().int().nonnegative().optional(),
+  /** Sort order */
+  order: zod.z.enum(["asc", "desc"]).optional(),
+  /** Field to sort by */
+  orderby: zod.z.string().optional()
+});
+zod.z.object({
+  /** Total number of items */
+  total: zod.z.number(),
+  /** Total number of pages */
+  totalPages: zod.z.number(),
+  /** Current page */
+  currentPage: zod.z.number(),
+  /** Items per page */
+  perPage: zod.z.number()
+});
+zod.z.object({
+  username: zod.z.string(),
+  password: zod.z.string()
+});
+var JwtTokenResponseSchema = zod.z.object({
+  token: zod.z.string(),
+  user_email: zod.z.string(),
+  user_nicename: zod.z.string(),
+  user_display_name: zod.z.string()
+});
+zod.z.object({
+  code: zod.z.string(),
+  data: zod.z.object({
+    status: zod.z.number()
+  })
+});
+zod.z.object({
+  code: zod.z.string(),
+  message: zod.z.string(),
+  data: zod.z.object({
+    status: zod.z.number()
+  }).optional()
+});
+var RenderedContentSchema = zod.z.object({
+  rendered: zod.z.string(),
+  protected: zod.z.boolean().optional()
+});
+var GuidSchema = zod.z.object({
+  rendered: zod.z.string()
+});
+zod.z.enum([
+  "publish",
+  "future",
+  "draft",
+  "pending",
+  "private",
+  "trash",
+  "auto-draft",
+  "inherit"
+]);
+var HalLinkItemSchema = zod.z.object({
+  href: zod.z.string(),
+  embeddable: zod.z.boolean().optional(),
+  templated: zod.z.boolean().optional()
+});
+var HalLinksSchema = zod.z.object({
+  self: zod.z.array(HalLinkItemSchema).optional(),
+  collection: zod.z.array(HalLinkItemSchema).optional(),
+  about: zod.z.array(HalLinkItemSchema).optional(),
+  author: zod.z.array(HalLinkItemSchema).optional(),
+  replies: zod.z.array(HalLinkItemSchema).optional(),
+  "wp:featuredmedia": zod.z.array(HalLinkItemSchema).optional(),
+  "wp:attachment": zod.z.array(HalLinkItemSchema).optional(),
+  "wp:term": zod.z.array(HalLinkItemSchema).optional(),
+  "wp:post_type": zod.z.array(HalLinkItemSchema).optional(),
+  curies: zod.z.array(
+    zod.z.object({
+      name: zod.z.string(),
+      href: zod.z.string(),
+      templated: zod.z.boolean()
+    })
+  ).optional()
+}).passthrough();
+zod.z.object({
+  id: zod.z.number(),
+  date: zod.z.string(),
+  date_gmt: zod.z.string(),
+  modified: zod.z.string(),
+  modified_gmt: zod.z.string(),
+  slug: zod.z.string(),
+  status: zod.z.string(),
+  type: zod.z.string(),
+  link: zod.z.string(),
+  _links: HalLinksSchema.optional()
+});
+var CategorySchema = zod.z.object({
+  id: zod.z.number(),
+  count: zod.z.number(),
+  description: zod.z.string().optional(),
+  link: zod.z.string(),
+  name: zod.z.string(),
+  slug: zod.z.string(),
+  taxonomy: zod.z.string(),
+  parent: zod.z.number(),
+  meta: zod.z.any().optional(),
+  _links: HalLinksSchema.optional()
+});
+var CategoriesListSchema = zod.z.array(CategorySchema);
+paginationParamsSchema.extend({
+  context: zod.z.enum(["view", "embed", "edit"]).optional(),
+  search: zod.z.string().optional(),
+  exclude: zod.z.array(zod.z.number()).optional(),
+  include: zod.z.array(zod.z.number()).optional(),
+  hide_empty: zod.z.boolean().optional(),
+  parent: zod.z.number().optional(),
+  post: zod.z.number().optional(),
+  slug: zod.z.string().optional()
+});
+var TagSchema = zod.z.object({
+  id: zod.z.number(),
+  count: zod.z.number(),
+  description: zod.z.string().optional(),
+  link: zod.z.string(),
+  name: zod.z.string(),
+  slug: zod.z.string(),
+  taxonomy: zod.z.string(),
+  meta: zod.z.any().optional(),
+  _links: HalLinksSchema.optional()
+});
+zod.z.array(TagSchema);
+var MediaSizeSchema = zod.z.object({
+  file: zod.z.string(),
+  width: zod.z.number(),
+  height: zod.z.number(),
+  filesize: zod.z.number().optional(),
+  mime_type: zod.z.string(),
+  source_url: zod.z.string()
+});
+var MediaSizesSchema = zod.z.object({
+  thumbnail: MediaSizeSchema.optional(),
+  medium: MediaSizeSchema.optional(),
+  medium_large: MediaSizeSchema.optional(),
+  large: MediaSizeSchema.optional(),
+  full: MediaSizeSchema.optional()
+}).passthrough();
+var ImageMetaSchema = zod.z.object({
+  aperture: zod.z.string().optional(),
+  credit: zod.z.string().optional(),
+  camera: zod.z.string().optional(),
+  caption: zod.z.string().optional(),
+  created_timestamp: zod.z.string().optional(),
+  copyright: zod.z.string().optional(),
+  focal_length: zod.z.string().optional(),
+  iso: zod.z.string().optional(),
+  shutter_speed: zod.z.string().optional(),
+  title: zod.z.string().optional(),
+  orientation: zod.z.string().optional(),
+  keywords: zod.z.array(zod.z.string()).optional()
+});
+var MediaDetailsSchema = zod.z.object({
+  width: zod.z.number(),
+  height: zod.z.number(),
+  file: zod.z.string(),
+  filesize: zod.z.number().optional(),
+  sizes: MediaSizesSchema,
+  image_meta: ImageMetaSchema.optional()
+});
+var MediaSchema = zod.z.object({
+  id: zod.z.number(),
+  date: zod.z.string(),
+  date_gmt: zod.z.string(),
+  guid: GuidSchema,
+  modified: zod.z.string(),
+  modified_gmt: zod.z.string(),
+  slug: zod.z.string(),
+  status: zod.z.string(),
+  type: zod.z.string(),
+  link: zod.z.string(),
+  title: RenderedContentSchema,
+  author: zod.z.number(),
+  comment_status: zod.z.string(),
+  ping_status: zod.z.string(),
+  template: zod.z.string().optional(),
+  meta: zod.z.any().optional(),
+  description: RenderedContentSchema,
+  caption: RenderedContentSchema,
+  alt_text: zod.z.string(),
+  media_type: zod.z.string(),
+  mime_type: zod.z.string(),
+  media_details: MediaDetailsSchema,
+  post: zod.z.number().nullable(),
+  source_url: zod.z.string(),
+  _links: HalLinksSchema.optional()
+});
+zod.z.array(MediaSchema);
+var PostSchema = zod.z.object({
+  id: zod.z.number(),
+  date: zod.z.string(),
+  date_gmt: zod.z.string(),
+  guid: GuidSchema,
+  modified: zod.z.string(),
+  modified_gmt: zod.z.string(),
+  slug: zod.z.string(),
+  status: zod.z.string(),
+  type: zod.z.string(),
+  link: zod.z.string(),
+  title: RenderedContentSchema,
+  content: RenderedContentSchema,
+  excerpt: RenderedContentSchema,
+  author: zod.z.number(),
+  featured_media: zod.z.number(),
+  comment_status: zod.z.string(),
+  ping_status: zod.z.string(),
+  sticky: zod.z.boolean(),
+  template: zod.z.string(),
+  format: zod.z.string(),
+  meta: zod.z.any().optional(),
+  categories: zod.z.array(zod.z.number()),
+  tags: zod.z.array(zod.z.number()).optional(),
+  _links: HalLinksSchema.optional()
+});
+var PostsListSchema = zod.z.array(PostSchema);
+paginationParamsSchema.extend({
+  context: zod.z.enum(["view", "embed", "edit"]).optional(),
+  search: zod.z.string().optional(),
+  after: zod.z.string().optional(),
+  before: zod.z.string().optional(),
+  author: zod.z.union([zod.z.number(), zod.z.array(zod.z.number())]).optional(),
+  author_exclude: zod.z.array(zod.z.number()).optional(),
+  exclude: zod.z.array(zod.z.number()).optional(),
+  include: zod.z.array(zod.z.number()).optional(),
+  categories: zod.z.union([zod.z.number(), zod.z.array(zod.z.number())]).optional(),
+  categories_exclude: zod.z.array(zod.z.number()).optional(),
+  tags: zod.z.union([zod.z.number(), zod.z.array(zod.z.number())]).optional(),
+  tags_exclude: zod.z.array(zod.z.number()).optional(),
+  sticky: zod.z.boolean().optional()
+});
+var EmbeddedPostSchema = zod.z.object({
+  id: zod.z.number(),
+  title: zod.z.string(),
+  content: zod.z.string(),
+  featured_image: zod.z.string().optional(),
+  published_date: zod.z.string(),
+  categories: zod.z.array(
+    zod.z.object({
+      id: zod.z.number(),
+      name: zod.z.string(),
+      slug: zod.z.string(),
+      taxonomy: zod.z.string().optional(),
+      description: zod.z.string().optional(),
+      parent: zod.z.number().optional(),
+      count: zod.z.number().optional()
+    })
+  ).optional()
+});
+zod.z.array(EmbeddedPostSchema);
+var AvatarUrlsSchema = zod.z.object({
+  "24": zod.z.string().optional(),
+  "48": zod.z.string().optional(),
+  "96": zod.z.string().optional()
+});
+var UserSchema = zod.z.object({
+  id: zod.z.number(),
+  username: zod.z.string().optional(),
+  // Only in edit context
+  name: zod.z.string(),
+  first_name: zod.z.string().optional(),
+  last_name: zod.z.string().optional(),
+  email: zod.z.string().optional(),
+  // Only for current user or admin
+  url: zod.z.string(),
+  description: zod.z.string(),
+  link: zod.z.string(),
+  locale: zod.z.string().optional(),
+  // Only for current user
+  nickname: zod.z.string().optional(),
+  // Only in edit context
+  slug: zod.z.string(),
+  registered_date: zod.z.string().optional(),
+  // Only in edit context
+  roles: zod.z.array(zod.z.string()).optional(),
+  // Only in edit context
+  capabilities: zod.z.record(zod.z.boolean()).optional(),
+  // Only in edit context
+  extra_capabilities: zod.z.record(zod.z.boolean()).optional(),
+  // Only in edit context
+  avatar_urls: AvatarUrlsSchema.optional(),
+  meta: zod.z.any().optional(),
+  _links: HalLinksSchema.optional()
+});
+zod.z.array(UserSchema);
+var CurrentUserSchema = UserSchema.extend({
+  username: zod.z.string(),
+  email: zod.z.string(),
+  locale: zod.z.string(),
+  nickname: zod.z.string(),
+  registered_date: zod.z.string(),
+  roles: zod.z.array(zod.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__default.default.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;
+};
+
+// src/testing/healthCheck.ts
+async function runCheck(name, endpoint, fn) {
+  const start = Date.now();
+  try {
+    const data = await fn();
+    return {
+      success: true,
+      endpoint,
+      message: `${name} check passed`,
+      data,
+      durationMs: Date.now() - start
+    };
+  } catch (err) {
+    const error2 = err instanceof Error ? err : new Error(String(err));
+    return {
+      success: false,
+      endpoint,
+      message: `${name} check failed: ${error2.message}`,
+      error: error2,
+      durationMs: Date.now() - start
+    };
+  }
+}
+async function runHealthCheck(client) {
+  const results = [];
+  results.push(
+    await runCheck("Posts", "/wp/v2/posts", async () => {
+      const response = await client.posts.list({ per_page: 1 });
+      return {
+        count: response.data.length,
+        total: response.pagination.total,
+        hasData: response.data.length > 0
+      };
+    })
+  );
+  results.push(
+    await runCheck("Categories", "/wp/v2/categories", async () => {
+      const response = await client.categories.list({ per_page: 1 });
+      return {
+        count: response.data.length,
+        total: response.pagination.total,
+        hasData: response.data.length > 0
+      };
+    })
+  );
+  const postsResult = results[0];
+  if (postsResult?.success && postsResult.data) {
+    const postsData = postsResult.data;
+    if (postsData.count > 0) {
+      results.push(
+        await runCheck("Media", "/wp/v2/media", async () => {
+          const posts = await client.posts.list({ per_page: 1 });
+          const post = posts.data[0];
+          if (post && post.featured_media > 0) {
+            const media = await client.media.get(post.featured_media);
+            return {
+              id: media.id,
+              type: media.media_type,
+              hasUrl: !!media.source_url
+            };
+          }
+          return { skipped: true, reason: "No featured media on first post" };
+        })
+      );
+    }
+  }
+  results.push(
+    await runCheck("Schema Validation", "/wp/v2/posts", async () => {
+      const response = await client.posts.list({ per_page: 1 });
+      if (response.data.length === 0) {
+        return { skipped: true, reason: "No posts available" };
+      }
+      const post = response.data[0];
+      const requiredFields = [
+        "id",
+        "title",
+        "content",
+        "excerpt",
+        "date",
+        "slug",
+        "status",
+        "categories"
+      ];
+      const missingFields = requiredFields.filter(
+        (field) => !(field in post) || post[field] === void 0
+      );
+      if (missingFields.length > 0) {
+        throw new Error(`Missing required fields: ${missingFields.join(", ")}`);
+      }
+      return { validatedFields: requiredFields };
+    })
+  );
+  results.push(
+    await runCheck("Pagination Headers", "/wp/v2/posts", async () => {
+      const response = await client.posts.list({ per_page: 1, page: 1 });
+      const { pagination } = response;
+      if (pagination.total === 0 && pagination.totalPages === 0) {
+        return {
+          warning: "Pagination headers may be missing or site has no posts"
+        };
+      }
+      return {
+        total: pagination.total,
+        totalPages: pagination.totalPages,
+        hasNextPage: pagination.hasNextPage
+      };
+    })
+  );
+  const passed = results.filter((r) => r.success).length;
+  const failed = results.filter((r) => !r.success).length;
+  return {
+    baseURL: client.config.baseURL,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    overall: failed === 0,
+    results,
+    summary: {
+      passed,
+      failed,
+      total: results.length
+    }
+  };
+}
+function createHealthChecker(config) {
+  const client = createClient(config);
+  return () => runHealthCheck(client);
+}
+function assertHealthy(report) {
+  if (!report.overall) {
+    const failures = report.results.filter((r) => !r.success).map((r) => `  - ${r.endpoint}: ${r.message}`).join("\n");
+    throw new Error(
+      `WordPress API health check failed (${report.summary.failed}/${report.summary.total}):
+${failures}`
+    );
+  }
+}
+
+// src/testing/createTestSuite.ts
+function createWordPressTestSuite(options) {
+  const { config, timeout = 3e4, skipMedia = false, skipAuth = true } = options;
+  const g = globalThis;
+  const describeFn = options.describe || g.describe;
+  const itFn = options.it || g.it;
+  const expectFn = options.expect || g.expect;
+  if (!describeFn || !itFn || !expectFn) {
+    throw new Error(
+      "Test framework functions not found. Either run this in a Jest/Vitest environment or pass describe, it, and expect as options."
+    );
+  }
+  describeFn("WordPress API Integration", () => {
+    const client = createClient(config);
+    describeFn("Health Check", () => {
+      itFn(
+        "should pass all health checks",
+        async () => {
+          const report = await runHealthCheck(client);
+          assertHealthy(report);
+          expectFn(report.overall).toBe(true);
+          expectFn(report.summary.failed).toBe(0);
+        },
+        timeout
+      );
+    });
+    describeFn("Posts API", () => {
+      itFn(
+        "should fetch posts list",
+        async () => {
+          const result = await client.posts.list({ per_page: 5 });
+          expectFn(result).toHaveProperty("data");
+          expectFn(result).toHaveProperty("pagination");
+          expectFn(Array.isArray(result.data)).toBe(true);
+          expectFn(result.pagination).toHaveProperty("total");
+          expectFn(result.pagination).toHaveProperty("totalPages");
+        },
+        timeout
+      );
+      itFn(
+        "should fetch single post when posts exist",
+        async () => {
+          const list = await client.posts.list({ per_page: 1 });
+          if (list.data.length === 0) {
+            console.warn("Skipping single post test: no posts available");
+            return;
+          }
+          const post = await client.posts.get(list.data[0].id);
+          expectFn(post).toHaveProperty("id");
+          expectFn(post).toHaveProperty("title");
+          expectFn(post).toHaveProperty("content");
+          expectFn(post.title).toHaveProperty("rendered");
+          expectFn(post.content).toHaveProperty("rendered");
+        },
+        timeout
+      );
+      itFn(
+        "should fetch post by slug when posts exist",
+        async () => {
+          const list = await client.posts.list({ per_page: 1 });
+          if (list.data.length === 0) {
+            console.warn("Skipping slug test: no posts available");
+            return;
+          }
+          const post = await client.posts.getBySlug(list.data[0].slug);
+          expectFn(post).not.toBeNull();
+          expectFn(post?.slug).toBe(list.data[0].slug);
+        },
+        timeout
+      );
+      itFn(
+        "should handle pagination correctly",
+        async () => {
+          const page1 = await client.posts.list({ per_page: 2, page: 1 });
+          expectFn(page1.pagination.page).toBe(1);
+          if (page1.pagination.hasNextPage) {
+            const page2 = await client.posts.list({ per_page: 2, page: 2 });
+            expectFn(page2.pagination.page).toBe(2);
+            expectFn(page2.pagination.hasPrevPage).toBe(true);
+          }
+        },
+        timeout
+      );
+    });
+    describeFn("Categories API", () => {
+      itFn(
+        "should fetch categories list",
+        async () => {
+          const result = await client.categories.list({ per_page: 10 });
+          expectFn(result).toHaveProperty("data");
+          expectFn(result).toHaveProperty("pagination");
+          expectFn(Array.isArray(result.data)).toBe(true);
+        },
+        timeout
+      );
+      itFn(
+        "should fetch single category when categories exist",
+        async () => {
+          const list = await client.categories.list({ per_page: 1 });
+          if (list.data.length === 0) {
+            console.warn("Skipping single category test: no categories available");
+            return;
+          }
+          const category = await client.categories.get(list.data[0].id);
+          expectFn(category).toHaveProperty("id");
+          expectFn(category).toHaveProperty("name");
+          expectFn(category).toHaveProperty("slug");
+          expectFn(category).toHaveProperty("count");
+        },
+        timeout
+      );
+    });
+    if (!skipMedia) {
+      describeFn("Media API", () => {
+        itFn(
+          "should fetch media item when posts have featured media",
+          async () => {
+            const posts = await client.posts.list({ per_page: 10 });
+            const postWithMedia = posts.data.find((p) => p.featured_media > 0);
+            if (!postWithMedia) {
+              console.warn("Skipping media test: no posts with featured media");
+              return;
+            }
+            const media = await client.media.get(postWithMedia.featured_media);
+            expectFn(media).toHaveProperty("id");
+            expectFn(media).toHaveProperty("source_url");
+            expectFn(media).toHaveProperty("media_type");
+            expectFn(media).toHaveProperty("media_details");
+            expectFn(media.media_details).toHaveProperty("sizes");
+          },
+          timeout
+        );
+      });
+    }
+    if (!skipAuth) {
+      describeFn("Auth API", () => {
+        itFn(
+          "should validate token when JWT is configured",
+          async () => {
+            if (!config.jwtToken) {
+              console.warn("Skipping auth test: no JWT token configured");
+              return;
+            }
+            const isValid = await client.auth.validateToken();
+            expectFn(typeof isValid).toBe("boolean");
+          },
+          timeout
+        );
+      });
+    }
+  });
+}
+
+exports.assertHealthy = assertHealthy;
+exports.createHealthChecker = createHealthChecker;
+exports.createWordPressTestSuite = createWordPressTestSuite;
+exports.runHealthCheck = runHealthCheck;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map