@atomic-solutions/wordpress-api-client 0.1.0

package/dist/http/index.js

@@ -0,0 +1,667 @@
+import { isAxiosError } from 'axios';
+
+// 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;
+  }
+};
+var isZodError = (error2) => {
+  return error2 instanceof Error && error2.name === "ZodError";
+};
+
+// 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);
+    }
+  );
+};
+
+export { handleApiResponse, handlePaginatedApiResponse, isZodError, setupErrorInterceptor, setupRequestInterceptor, setupResponseInterceptor };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map