Implement comprehensive Trustpilot webhooks and review management

- Enhanced trustpilot.app.ts with full authentication and API methods
- Added comprehensive constants and utilities
- Implemented all requested actions:
  - Fetch service reviews with filtering and pagination
  - Fetch service review by ID
  - Fetch product reviews with filtering and pagination
  - Fetch product review by ID
  - Reply to service reviews
  - Reply to product reviews
- Created webhook infrastructure with base class
- Implemented all requested webhook sources:
  - Review created events
  - Review revised events
  - Review deleted events
  - Reply created events
  - Invitation sent events
  - Invitation failed events
- Added proper error handling, validation, and retry logic
- Supports both API key and OAuth authentication
- Includes comprehensive prop definitions and business unit selection

Author: seynadio

components/trustpilot/app/trustpilot.app.ts

@@ -1,13 +1,394 @@
 import { defineApp } from "@pipedream/types";
+import { axios } from "@pipedream/platform";
+import { 
+  BASE_URL, 
+  ENDPOINTS, 
+  DEFAULT_LIMIT, 
+  MAX_LIMIT, 
+  SORT_OPTIONS,
+  RATING_SCALE,
+  RETRY_CONFIG,
+  HTTP_STATUS,
+} from "../common/constants.mjs";
+import { 
+  buildUrl, 
+  parseReview, 
+  parseBusinessUnit, 
+  parseWebhookPayload,
+  validateBusinessUnitId,
+  validateReviewId,
+  formatQueryParams,
+  parseApiError,
+  sleep,
+} from "../common/utils.mjs";
 
 export default defineApp({
   type: "app",
   app: "trustpilot",
-  propDefinitions: {},
+  propDefinitions: {
+    businessUnitId: {
+      type: "string",
+      label: "Business Unit ID",
+      description: "The unique identifier for your business unit on Trustpilot",
+      async options() {
+        try {
+          const businessUnits = await this.searchBusinessUnits({
+            query: "",
+            limit: 20,
+          });
+          return businessUnits.map(unit => ({
+            label: unit.displayName,
+            value: unit.id,
+          }));
+        } catch (error) {
+          console.error("Error fetching business units:", error);
+          return [];
+        }
+      },
+    },
+    reviewId: {
+      type: "string",
+      label: "Review ID",
+      description: "The unique identifier for a review",
+    },
+    stars: {
+      type: "integer",
+      label: "Star Rating",
+      description: "Filter by star rating (1-5)",
+      options: RATING_SCALE,
+      optional: true,
+    },
+    sortBy: {
+      type: "string",
+      label: "Sort By",
+      description: "How to sort the results",
+      options: Object.entries(SORT_OPTIONS).map(([key, value]) => ({
+        label: key.replace(/_/g, " ").toLowerCase(),
+        value,
+      })),
+      optional: true,
+      default: SORT_OPTIONS.CREATED_AT_DESC,
+    },
+    limit: {
+      type: "integer",
+      label: "Limit",
+      description: "Maximum number of results to return",
+      min: 1,
+      max: MAX_LIMIT,
+      default: DEFAULT_LIMIT,
+      optional: true,
+    },
+    includeReportedReviews: {
+      type: "boolean",
+      label: "Include Reported Reviews",
+      description: "Whether to include reviews that have been reported",
+      default: false,
+      optional: true,
+    },
+    tags: {
+      type: "string[]",
+      label: "Tags",
+      description: "Filter reviews by tags",
+      optional: true,
+    },
+    language: {
+      type: "string",
+      label: "Language",
+      description: "Filter reviews by language (ISO 639-1 code)",
+      optional: true,
+    },
+  },
   methods: {
-    // this.$auth contains connected account data
+    // Authentication and base request methods
+    _getAuthHeaders() {
+      const headers = {
+        "Content-Type": "application/json",
+        "User-Agent": "Pipedream/1.0",
+      };
+
+      if (this.$auth?.api_key) {
+        headers["apikey"] = this.$auth.api_key;
+      }
+
+      if (this.$auth?.oauth_access_token) {
+        headers["Authorization"] = `Bearer ${this.$auth.oauth_access_token}`;
+      }
+
+      return headers;
+    },
+
+    async _makeRequest({ endpoint, method = "GET", params = {}, data = null, ...args }) {
+      const url = `${BASE_URL}${endpoint}`;
+      const headers = this._getAuthHeaders();
+      
+      const config = {
+        method,
+        url,
+        headers,
+        params: formatQueryParams(params),
+        timeout: 30000,
+        ...args,
+      };
+
+      if (data) {
+        config.data = data;
+      }
+
+      try {
+        const response = await axios(this, config);
+        return response.data || response;
+      } catch (error) {
+        const parsedError = parseApiError(error);
+        throw new Error(`Trustpilot API Error: ${parsedError.message} (${parsedError.code})`);
+      }
+    },
+
+    async _makeRequestWithRetry(config, retries = RETRY_CONFIG.MAX_RETRIES) {
+      try {
+        return await this._makeRequest(config);
+      } catch (error) {
+        if (retries > 0 && error.response?.status === HTTP_STATUS.TOO_MANY_REQUESTS) {
+          const delay = Math.min(RETRY_CONFIG.INITIAL_DELAY * (RETRY_CONFIG.MAX_RETRIES - retries + 1), RETRY_CONFIG.MAX_DELAY);
+          await sleep(delay);
+          return this._makeRequestWithRetry(config, retries - 1);
+        }
+        throw error;
+      }
+    },
+
+    // Business Unit methods
+    async getBusinessUnit(businessUnitId) {
+      if (!validateBusinessUnitId(businessUnitId)) {
+        throw new Error("Invalid business unit ID");
+      }
+
+      const endpoint = buildUrl(ENDPOINTS.BUSINESS_UNIT_BY_ID, { businessUnitId });
+      const response = await this._makeRequest({ endpoint });
+      return parseBusinessUnit(response);
+    },
+
+    async searchBusinessUnits({ query = "", limit = DEFAULT_LIMIT, offset = 0 } = {}) {
+      const response = await this._makeRequest({
+        endpoint: ENDPOINTS.BUSINESS_UNITS,
+        params: {
+          query,
+          limit,
+          offset,
+        },
+      });
+
+      return response.businessUnits?.map(parseBusinessUnit) || [];
+    },
+
+    // Service Review methods
+    async getServiceReviews({
+      businessUnitId,
+      stars = null,
+      sortBy = SORT_OPTIONS.CREATED_AT_DESC,
+      limit = DEFAULT_LIMIT,
+      offset = 0,
+      includeReportedReviews = false,
+      tags = [],
+      language = null,
+    } = {}) {
+      if (!validateBusinessUnitId(businessUnitId)) {
+        throw new Error("Invalid business unit ID");
+      }
+
+      const endpoint = buildUrl(ENDPOINTS.PRIVATE_SERVICE_REVIEWS, { businessUnitId });
+      const params = {
+        stars,
+        orderBy: sortBy,
+        perPage: limit,
+        page: Math.floor(offset / limit) + 1,
+        includeReportedReviews,
+        language,
+      };
+
+      if (tags.length > 0) {
+        params.tags = tags.join(",");
+      }
+
+      const response = await this._makeRequestWithRetry({
+        endpoint,
+        params,
+      });
+
+      return {
+        reviews: response.reviews?.map(parseReview) || [],
+        pagination: {
+          total: response.pagination?.total || 0,
+          page: response.pagination?.page || 1,
+          perPage: response.pagination?.perPage || limit,
+          hasMore: response.pagination?.hasMore || false,
+        },
+      };
+    },
+
+    async getServiceReviewById({ businessUnitId, reviewId }) {
+      if (!validateBusinessUnitId(businessUnitId)) {
+        throw new Error("Invalid business unit ID");
+      }
+      if (!validateReviewId(reviewId)) {
+        throw new Error("Invalid review ID");
+      }
+
+      const endpoint = buildUrl(ENDPOINTS.PRIVATE_SERVICE_REVIEW_BY_ID, { businessUnitId, reviewId });
+      const response = await this._makeRequest({ endpoint });
+      return parseReview(response);
+    },
+
+    async replyToServiceReview({ businessUnitId, reviewId, message }) {
+      if (!validateBusinessUnitId(businessUnitId)) {
+        throw new Error("Invalid business unit ID");
+      }
+      if (!validateReviewId(reviewId)) {
+        throw new Error("Invalid review ID");
+      }
+      if (!message || typeof message !== 'string') {
+        throw new Error("Reply message is required");
+      }
+
+      const endpoint = buildUrl(ENDPOINTS.REPLY_TO_SERVICE_REVIEW, { businessUnitId, reviewId });
+      const response = await this._makeRequest({
+        endpoint,
+        method: "POST",
+        data: { message },
+      });
+      return response;
+    },
+
+    // Product Review methods
+    async getProductReviews({
+      businessUnitId,
+      stars = null,
+      sortBy = SORT_OPTIONS.CREATED_AT_DESC,
+      limit = DEFAULT_LIMIT,
+      offset = 0,
+      includeReportedReviews = false,
+      tags = [],
+      language = null,
+    } = {}) {
+      if (!validateBusinessUnitId(businessUnitId)) {
+        throw new Error("Invalid business unit ID");
+      }
+
+      const endpoint = buildUrl(ENDPOINTS.PRIVATE_PRODUCT_REVIEWS, { businessUnitId });
+      const params = {
+        stars,
+        orderBy: sortBy,
+        perPage: limit,
+        page: Math.floor(offset / limit) + 1,
+        includeReportedReviews,
+        language,
+      };
+
+      if (tags.length > 0) {
+        params.tags = tags.join(",");
+      }
+
+      const response = await this._makeRequestWithRetry({
+        endpoint,
+        params,
+      });
+
+      return {
+        reviews: response.reviews?.map(parseReview) || [],
+        pagination: {
+          total: response.pagination?.total || 0,
+          page: response.pagination?.page || 1,
+          perPage: response.pagination?.perPage || limit,
+          hasMore: response.pagination?.hasMore || false,
+        },
+      };
+    },
+
+    async getProductReviewById({ reviewId }) {
+      if (!validateReviewId(reviewId)) {
+        throw new Error("Invalid review ID");
+      }
+
+      const endpoint = buildUrl(ENDPOINTS.PRIVATE_PRODUCT_REVIEW_BY_ID, { reviewId });
+      const response = await this._makeRequest({ endpoint });
+      return parseReview(response);
+    },
+
+    async replyToProductReview({ reviewId, message }) {
+      if (!validateReviewId(reviewId)) {
+        throw new Error("Invalid review ID");
+      }
+      if (!message || typeof message !== 'string') {
+        throw new Error("Reply message is required");
+      }
+
+      const endpoint = buildUrl(ENDPOINTS.REPLY_TO_PRODUCT_REVIEW, { reviewId });
+      const response = await this._makeRequest({
+        endpoint,
+        method: "POST",
+        data: { message },
+      });
+      return response;
+    },
+
+    // Webhook methods
+    async createWebhook({ url, events = [], businessUnitId = null }) {
+      if (!url) {
+        throw new Error("Webhook URL is required");
+      }
+      if (!Array.isArray(events) || events.length === 0) {
+        throw new Error("At least one event must be specified");
+      }
+
+      const data = {
+        url,
+        events,
+      };
+
+      if (businessUnitId) {
+        data.businessUnitId = businessUnitId;
+      }
+
+      const response = await this._makeRequest({
+        endpoint: ENDPOINTS.WEBHOOKS,
+        method: "POST",
+        data,
+      });
+      return response;
+    },
+
+    async deleteWebhook(webhookId) {
+      if (!webhookId) {
+        throw new Error("Webhook ID is required");
+      }
+
+      const endpoint = buildUrl(ENDPOINTS.WEBHOOK_BY_ID, { webhookId });
+      await this._makeRequest({
+        endpoint,
+        method: "DELETE",
+      });
+    },
+
+    async listWebhooks() {
+      const response = await this._makeRequest({
+        endpoint: ENDPOINTS.WEBHOOKS,
+      });
+      return response.webhooks || [];
+    },
+
+    // Utility methods
+    parseWebhookPayload(payload) {
+      return parseWebhookPayload(payload);
+    },
+
+    validateWebhookSignature(payload, signature, secret) {
+      // TODO: Implement webhook signature validation when Trustpilot provides it
+      return true;
+    },
+
+    // Legacy method for debugging
     authKeys() {
-      console.log(Object.keys(this.$auth));
+      console.log("Auth keys:", Object.keys(this.$auth || {}));
+      return Object.keys(this.$auth || {});
     },
   },
 });