@pipedream/twitter 2.3.3 → 2.3.4

package/dist/actions/retweet/retweet.mjs

@@ -1,42 +1,522 @@
-import common from "../../common/appValidation.mjs";
-import { ACTION_ERROR_MESSAGE } from "../../common/errorMessage.mjs";
-import { defineAction } from "@pipedream/types";
-const DOCS_LINK = "https://developer.twitter.com/en/docs/twitter-api/tweets/retweets/api-reference/post-users-id-retweets";
-export default defineAction({
-    ...common,
-    key: "twitter-retweet",
-    name: "Retweet a tweet",
-    description: `Retweet a tweet specified by ID. [See the documentation](${DOCS_LINK})`,
-    version: "2.0.9",
-    annotations: {
-        destructiveHint: false,
-        openWorldHint: true,
-        readOnlyHint: false,
-    },
-    type: "action",
-    props: {
-        ...common.props,
-        tweetId: {
-            propDefinition: [
-                common.props.app,
-                "tweetId",
-            ],
-            description: "The ID of the tweet you'd like to retweet",
-        },
+// components/twitter/app/twitter.app.ts
+import OAuth from "oauth-1.0a";
+import crypto from "crypto";
+import { defineApp } from "@pipedream/types";
+import {
+  axios,
+  transformConfigForOauth,
+  ConfigurationError
+} from "@pipedream/platform";
+
+// components/twitter/common/errorMessage.ts
+var ERROR_URL = "https://developer.twitter.com/en/docs/twitter-api/getting-started/about-twitter-api#item0";
+var ERROR_MESSAGE = `Check if your app is properly configured on the [Twitter Developer Portal](${ERROR_URL}), and if your plan has access to the endpoint used by this component.`;
+var ACTION_ERROR_MESSAGE = `${ERROR_MESSAGE} Additional debugging information has been exported from the step.`;
+var PROBLEM_BASE_URL = "https://api.twitter.com/2/problems";
+var ERROR_BY_TYPE = {
+  [`${PROBLEM_BASE_URL}/client-forbidden`]: "This X (Twitter) account appears to be on the Free plan, which only has access to **Create Tweets**. [Refer to Twitter's developer docs](https://developer.twitter.com/en/docs/twitter-api/getting-started/about-twitter-api#v2-access-leve) for the latest info on API access.",
+  ["about:blank"]: "A generic problem with no additional information beyond that provided by the HTTP status code.",
+  [`${PROBLEM_BASE_URL}/invalid-request`]: "A problem that indicates this request is invalid. If your request takes a POST body, ensure the contents is valid JSON and matches the [OpenAPI spec](https://api.twitter.com/2/openapi.json).",
+  [`${PROBLEM_BASE_URL}/resource-not-found`]: "A problem that indicates that a given Post, User, etc. does not exist.",
+  [`${PROBLEM_BASE_URL}/not-authorized-for-resource`]: "A problem that indicates you are not allowed to see a particular Post, User, etc.",
+  [`${PROBLEM_BASE_URL}/disallowed-resource`]: "A problem that indicates that the resource requested violates the precepts of this API.",
+  [`${PROBLEM_BASE_URL}/unsupported-authentication`]: "A problem that indicates that the authentication used is not supported.",
+  [`${PROBLEM_BASE_URL}/usage-capped`]: "A problem that indicates that a usage cap has been exceeded.",
+  [`${PROBLEM_BASE_URL}/streaming-connection`]: "A problem that indicates something is wrong with the connection.",
+  [`${PROBLEM_BASE_URL}/client-disconnected`]: "Your client has gone away.",
+  [`${PROBLEM_BASE_URL}/operational-disconnect`]: "You have been disconnected for operational reasons.",
+  [`${PROBLEM_BASE_URL}/rule-cap`]: "You have exceeded the maximum number of rules.",
+  [`${PROBLEM_BASE_URL}/rule-length`]: "You have exceeded the maximum number of characters allowed on your query or rule based on your access level. See [access levels](https://developer.twitter.com/en/docs/twitter-api/getting-started/about-twitter-api.html#Access).",
+  [`${PROBLEM_BASE_URL}/invalid-rules`]: "The rule you have submitted is invalid.",
+  [`${PROBLEM_BASE_URL}/duplicate-rules`]: "The rule you have submitted is a duplicate.",
+  [`${PROBLEM_BASE_URL}/conflict`]: "The rule you have submitted is in conflict with another rule.",
+  [`${PROBLEM_BASE_URL}/noncompliant-rules`]: "The rule you have submitted is not compliant with Twitter's Automation Rules",
+  [`${PROBLEM_BASE_URL}/not-authorized-for-field`]: "A problem that indicates you are not allowed to see a particular field.",
+  [`${PROBLEM_BASE_URL}/oauth1-permissions`]: "A problem that indicates you are not allowed to see a particular field.",
+  [`${PROBLEM_BASE_URL}/resource-unavailable`]: "A problem that indicates that a given Post, User, etc. is temporarily unavailable."
+};
+
+// components/twitter/app/twitter.app.ts
+var twitter_app_default = defineApp({
+  type: "app",
+  app: "twitter",
+  propDefinitions: {
+    maxResults: {
+      type: "integer",
+      label: "Max Results",
+      description: "Maximum amount of items to return. The maximum amount per request for each endpoint is included in the API documentation.",
+      optional: true
+    },
+    listId: {
+      type: "string",
+      label: "List ID",
+      description: "Select a **List** owned by the authenticated user, or use a custom *List ID*.",
+      async options() {
+        const userId = await this.getAuthenticatedUserId();
+        const lists = await this.getUserOwnedLists({
+          userId
+        });
+        return lists.data?.map(({
+          id,
+          name
+        }) => ({
+          label: name,
+          value: id
+        })) ?? [];
+      }
+    },
+    userNameOrId: {
+      type: "string",
+      label: "User Name or ID",
+      description: "A Twitter username (handle) prefixed with `@` (e.g. `@pipedream`). You can also use the string `me` to use the authenticated user (default), or a numeric User ID.",
+      optional: true,
+      default: "me"
+    },
+    // See comment on "../common/additionalProps.ts"
+    /*
+    includeAllFields: {
+      type: "boolean",
+      label: "Include All Metadata",
+      description: "If set to `false`, you can choose which fields will be returned for each data type.",
+      optional: true,
+      default: true,
+      reloadProps: true,
+    },
+    */
+    tweetId: {
+      type: "string",
+      label: "Tweet ID",
+      description: "The numerical ID of the tweet."
+    },
+    query: {
+      type: "string",
+      label: "Query",
+      description: "One query for matching Tweets. See the [Twitter API guide on building queries](https://developer.twitter.com/en/docs/twitter-api/tweets/search/integrate/build-a-query)."
+    }
+  },
+  methods: {
+    throwError(data) {
+      const errorMessage = ERROR_BY_TYPE[data?.type];
+      if (!errorMessage) {
+        return;
+      }
+      throw new ConfigurationError(errorMessage);
+    },
+    _getAuthHeader(config) {
+      const {
+        developer_consumer_key: devKey,
+        developer_consumer_secret: devSecret,
+        oauth_access_token: key,
+        oauth_refresh_token: secret
+      } = this.$auth;
+      const consumer = {
+        key: devKey,
+        secret: devSecret
+      };
+      const oauth = new OAuth({
+        consumer,
+        signature_method: "HMAC-SHA1",
+        hash_function(base_string, key2) {
+          return crypto.createHmac("sha1", key2).update(base_string).digest("base64");
+        }
+      });
+      const token = {
+        key,
+        secret
+      };
+      const requestData = transformConfigForOauth(config);
+      return oauth.toHeader(oauth.authorize(requestData, token));
+    },
+    _getBaseUrl() {
+      return "https://api.twitter.com/2";
+    },
+    async _httpRequest({
+      $ = this,
+      headers,
+      specialAuth = false,
+      throwError = true,
+      fallbackError,
+      ...args
+    }) {
+      const maxRetries = 3;
+      let response;
+      let counter = 1;
+      const config = {
+        baseURL: this._getBaseUrl(),
+        ...args
+      };
+      const authConfig = specialAuth ? {
+        ...config,
+        params: {},
+        data: {}
+      } : config;
+      const axiosConfig = {
+        debug: true,
+        ...config,
+        headers: {
+          ...headers,
+          ...this._getAuthHeader(authConfig)
+        }
+      };
+      do {
+        try {
+          response = await axios($, axiosConfig);
+        } catch (err) {
+          console.log(`Request error on attempt #${counter}: `, err);
+          if (counter === maxRetries) {
+            if (throwError && err.response?.data) {
+              this.throwError(err.response.data);
+            }
+            if (fallbackError) {
+              throw new ConfigurationError(fallbackError);
+            }
+            throw err;
+          }
+        }
+      } while (!response && ++counter <= maxRetries);
+      return response;
+    },
+    async _paginatedRequest({
+      maxResults = 100,
+      maxPerPage = 100,
+      params,
+      ...args
+    }) {
+      const totalData = [], totalErrors = [], totalIncludes = {};
+      let paginationToken;
+      let resultCount = 0;
+      do {
+        const perPage = Math.min(maxResults - resultCount, maxPerPage);
+        const {
+          data,
+          errors,
+          meta: { next_token },
+          includes
+        } = await this._httpRequest({
+          params: {
+            ...params,
+            max_results: perPage,
+            pagination_token: paginationToken
+          },
+          ...args
+        });
+        if (data) {
+          totalData.push(...Array.isArray(data) ? data : [
+            data
+          ]);
+        }
+        if (errors) {
+          totalErrors.push(...Array.isArray(errors) ? errors : [
+            errors
+          ]);
+        }
+        if (includes) {
+          Object.entries(includes).forEach(
+            ([
+              key,
+              value
+            ]) => {
+              if (!totalIncludes[key]) totalIncludes[key] = [];
+              totalIncludes[key].push(...value);
+            }
+          );
+        }
+        paginationToken = next_token;
+        resultCount += perPage;
+      } while (paginationToken && resultCount < maxResults);
+      return {
+        data: totalData,
+        errors: totalErrors,
+        includes: totalIncludes
+      };
+    },
+    async addUserToList({
+      listId,
+      ...args
+    }) {
+      return this._httpRequest({
+        method: "POST",
+        url: `/lists/${listId}/members`,
+        ...args
+      });
+    },
+    async createTweet(args) {
+      return this._httpRequest({
+        throwError: false,
+        method: "POST",
+        url: "/tweets",
+        ...args
+      });
+    },
+    async deleteTweet({
+      tweetId,
+      ...args
+    }) {
+      return this._httpRequest({
+        method: "DELETE",
+        url: `/tweets/${tweetId}`,
+        ...args
+      });
+    },
+    async followUser(args) {
+      const id = await this.getAuthenticatedUserId();
+      return this._httpRequest({
+        method: "POST",
+        url: `/users/${id}/following`,
+        ...args
+      });
+    },
+    async getListTweets({
+      listId,
+      ...args
+    }) {
+      return this._paginatedRequest({
+        url: `/lists/${listId}/tweets`,
+        ...args
+      });
+    },
+    async getTweet({
+      tweetId,
+      ...args
+    }) {
+      return this._httpRequest({
+        url: `/tweets/${tweetId}`,
+        ...args
+      });
+    },
+    async getAuthenticatedUser(args) {
+      return this._httpRequest({
+        url: "/users/me",
+        ...args
+      });
+    },
+    async getAuthenticatedUserId() {
+      const response = await this.getAuthenticatedUser();
+      return response.data.id;
     },
-    async run({ $ }) {
-        const { tweetId } = this;
-        const params = {
-            $,
-            data: {
-                tweet_id: tweetId,
-            },
-            fallbackError: ACTION_ERROR_MESSAGE,
-        };
-        const response = await this.app.retweet(params);
-        $.export("$summary", response.data?.retweeted !== true
-            ? "Retweet failed"
-            : "Tweet successfully retweeted");
-        return response;
+    async getDirectMessages(args) {
+      return this._paginatedRequest({
+        url: "/dm_events",
+        ...args
+      });
     },
+    async getUserLikedTweets({
+      userId,
+      ...args
+    }) {
+      return this._paginatedRequest({
+        url: `/users/${userId}/liked_tweets`,
+        ...args
+      });
+    },
+    async getUserOwnedLists({
+      userId,
+      ...args
+    }) {
+      return this._httpRequest({
+        url: `/users/${userId}/owned_lists`,
+        ...args
+      });
+    },
+    async getUserFollowedLists({
+      userId,
+      ...args
+    }) {
+      return this._paginatedRequest({
+        url: `/users/${userId}/followed_lists`,
+        ...args
+      });
+    },
+    async getUserMentions({
+      userId,
+      ...args
+    }) {
+      return this._paginatedRequest({
+        url: `/users/${userId}/mentions`,
+        ...args
+      });
+    },
+    async getUserTweets({
+      userId,
+      ...args
+    }) {
+      return this._paginatedRequest({
+        url: `/users/${userId}/tweets`,
+        ...args
+      });
+    },
+    async getUserByUsername(username) {
+      return this._httpRequest({
+        url: `/users/by/username/${username}`
+      });
+    },
+    async getUser({
+      userId,
+      ...args
+    }) {
+      return this._httpRequest({
+        url: `/users/${userId}`,
+        ...args
+      });
+    },
+    async likeTweet(args) {
+      const id = await this.getAuthenticatedUserId();
+      return this._httpRequest({
+        method: "POST",
+        url: `/users/${id}/likes`,
+        ...args
+      });
+    },
+    async getUserFollowers({
+      userId,
+      ...args
+    }) {
+      return this._paginatedRequest({
+        url: `/users/${userId}/followers`,
+        ...args
+      });
+    },
+    async getUserFollowing({
+      userId,
+      ...args
+    }) {
+      return this._paginatedRequest({
+        url: `/users/${userId}/following`,
+        ...args
+      });
+    },
+    async retweet(args) {
+      const id = await this.getAuthenticatedUserId();
+      return this._httpRequest({
+        method: "POST",
+        url: `/users/${id}/retweets`,
+        ...args
+      });
+    },
+    async searchTweets(args) {
+      return this._paginatedRequest({
+        url: "/tweets/search/recent",
+        ...args
+      });
+    },
+    async sendMessage({
+      userId,
+      ...args
+    }) {
+      return this._httpRequest({
+        method: "POST",
+        url: `/dm_conversations/with/${userId}/messages`,
+        ...args
+      });
+    },
+    async unfollowUser({
+      userId,
+      ...args
+    }) {
+      const id = await this.getAuthenticatedUserId();
+      return this._httpRequest({
+        method: "DELETE",
+        url: `/users/${id}/following/${userId}`,
+        ...args
+      });
+    },
+    async unlikeTweet({
+      tweetId,
+      ...args
+    }) {
+      const id = await this.getAuthenticatedUserId();
+      return this._httpRequest({
+        method: "DELETE",
+        url: `/users/${id}/likes/${tweetId}`,
+        ...args
+      });
+    },
+    async uploadMedia(args) {
+      return this._httpRequest({
+        baseURL: "https://upload.twitter.com/1.1",
+        url: "/media/upload.json",
+        method: "POST",
+        headers: {
+          "Content-Type": `multipart/form-data; boundary=${args.data.getBoundary()}`
+        },
+        specialAuth: true,
+        ...args
+      });
+    }
+  }
+});
+
+// components/twitter/common/appValidation.ts
+var appValidation_default = {
+  props: {
+    app: {
+      ...twitter_app_default,
+      reloadProps: true
+    }
+  },
+  async additionalProps() {
+    const q = "Pipedream";
+    const data = await this.getRecentTweets({
+      params: {
+        query: q
+      },
+      validateStatus: () => true
+    });
+    this.app.throwError(data);
+    return {};
+  },
+  methods: {
+    getRecentTweets(args = {}) {
+      return this.app._httpRequest({
+        url: "/tweets/search/recent",
+        ...args
+      });
+    }
+  }
+};
+
+// components/twitter/actions/retweet/retweet.ts
+import { defineAction } from "@pipedream/types";
+var DOCS_LINK = "https://developer.twitter.com/en/docs/twitter-api/tweets/retweets/api-reference/post-users-id-retweets";
+var retweet_default = defineAction({
+  ...appValidation_default,
+  key: "twitter-retweet",
+  name: "Retweet a tweet",
+  description: `Retweet a tweet specified by ID. [See the documentation](${DOCS_LINK})`,
+  version: "2.0.9",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: false
+  },
+  type: "action",
+  props: {
+    ...appValidation_default.props,
+    tweetId: {
+      propDefinition: [
+        appValidation_default.props.app,
+        "tweetId"
+      ],
+      description: "The ID of the tweet you'd like to retweet"
+    }
+  },
+  async run({ $ }) {
+    const { tweetId } = this;
+    const params = {
+      $,
+      data: {
+        tweet_id: tweetId
+      },
+      fallbackError: ACTION_ERROR_MESSAGE
+    };
+    const response = await this.app.retweet(params);
+    $.export(
+      "$summary",
+      response.data?.retweeted !== true ? "Retweet failed" : "Tweet successfully retweeted"
+    );
+    return response;
+  }
 });
+export {
+  retweet_default as default
+};