@pipedream/twitter 2.3.2 → 2.3.4

package/dist/actions/create-tweet/create-tweet.mjs

@@ -1,80 +1,546 @@
-import app from "../../app/twitter.app.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/manage-tweets/api-reference/post-tweets";
-export default defineAction({
-    key: "twitter-create-tweet",
-    name: "Create Tweet",
-    description: `Create a new tweet. [See the documentation](${DOCS_LINK})`,
-    version: "2.1.6",
-    type: "action",
-    props: {
-        app,
-        text: {
-            type: "string",
-            label: "Text",
-            description: "Text of the Tweet being created. Required if `Media IDs` is not set.",
-            optional: true,
-        },
-        inReplyToTweetId: {
-            type: "string",
-            label: "In Reply To Tweet (ID)",
-            description: "Tweet ID of the Tweet being replied to. Please note that this prop needs to be set if `Exclude Reply User IDs` is also set.",
-            optional: true,
-        },
-        excludeReplyUserIds: {
-            type: "string[]",
-            label: "Exclude Reply User IDs",
-            description: "A list of User IDs to be excluded from the reply Tweet thus removing a user from a thread.",
-            optional: true,
-        },
-        mediaIds: {
-            type: "string[]",
-            label: "Media IDs",
-            description: "A list of Media IDs being attached to the Tweet. This is only required if `Tagged User IDs` is set.",
-            optional: true,
-        },
-        taggedUserIds: {
-            type: "string[]",
-            label: "Tagged User IDs",
-            description: "A list of User IDs being tagged in the Tweet with Media. If the user you're tagging doesn't have photo-tagging enabled, their names won't show up in the list of tagged users even though the Tweet is successfully created.",
-            optional: true,
-        },
-        placeId: {
-            type: "string",
-            label: "Place ID",
-            description: "Place ID being attached to the Tweet for geo location.",
-            optional: true,
+// 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 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/actions/create-tweet/create-tweet.ts
+import { defineAction } from "@pipedream/types";
+var DOCS_LINK = "https://developer.twitter.com/en/docs/twitter-api/tweets/manage-tweets/api-reference/post-tweets";
+var create_tweet_default = defineAction({
+  key: "twitter-create-tweet",
+  name: "Create Tweet",
+  description: `Create a new tweet. [See the documentation](${DOCS_LINK})`,
+  version: "2.1.8",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: false
+  },
+  type: "action",
+  ai: "optimized",
+  props: {
+    app: twitter_app_default,
+    text: {
+      type: "string",
+      label: "Text",
+      description: "Text of the Tweet being created. Required if `Media IDs` is not set.",
+      optional: true
     },
-    async run({ $ }) {
-        const { text, inReplyToTweetId, excludeReplyUserIds, mediaIds, placeId, taggedUserIds, } = this;
-        const params = {
-            $,
-            data: {
-                text,
-                ...((inReplyToTweetId || excludeReplyUserIds) && {
-                    reply: {
-                        exclude_reply_user_ids: excludeReplyUserIds,
-                        in_reply_to_tweet_id: inReplyToTweetId,
-                    },
-                }),
-                ...((mediaIds || taggedUserIds) && {
-                    media: {
-                        media_ids: mediaIds,
-                        tagged_user_ids: taggedUserIds,
-                    },
-                }),
-                ...(placeId && {
-                    geo: {
-                        place_id: placeId,
-                    },
-                }),
-            },
-            fallbackError: ACTION_ERROR_MESSAGE,
-        };
-        const response = await this.app.createTweet(params);
-        $.export("$summary", `Successfully posted tweet (ID ${response.data?.id})`);
-        return response;
+    inReplyToTweetId: {
+      type: "string",
+      label: "In Reply To Tweet (ID)",
+      description: "Tweet ID of the Tweet being replied to. Please note that this prop needs to be set if `Exclude Reply User IDs` is also set.",
+      optional: true
     },
+    excludeReplyUserIds: {
+      type: "string[]",
+      label: "Exclude Reply User IDs",
+      description: "A list of User IDs to be excluded from the reply Tweet thus removing a user from a thread.",
+      optional: true
+    },
+    mediaIds: {
+      type: "string[]",
+      label: "Media IDs",
+      description: "A list of Media IDs being attached to the Tweet. This is only required if `Tagged User IDs` is set.",
+      optional: true
+    },
+    taggedUserIds: {
+      type: "string[]",
+      label: "Tagged User IDs",
+      description: "A list of User IDs being tagged in the Tweet with Media. If the user you're tagging doesn't have photo-tagging enabled, their names won't show up in the list of tagged users even though the Tweet is successfully created.",
+      optional: true
+    },
+    placeId: {
+      type: "string",
+      label: "Place ID",
+      description: "Place ID being attached to the Tweet for geo location.",
+      optional: true
+    }
+  },
+  async run({ $ }) {
+    const {
+      text,
+      inReplyToTweetId,
+      excludeReplyUserIds,
+      mediaIds,
+      placeId,
+      taggedUserIds
+    } = this;
+    const params = {
+      $,
+      data: {
+        text,
+        ...(inReplyToTweetId || excludeReplyUserIds) && {
+          reply: {
+            exclude_reply_user_ids: excludeReplyUserIds,
+            in_reply_to_tweet_id: inReplyToTweetId
+          }
+        },
+        ...(mediaIds || taggedUserIds) && {
+          media: {
+            media_ids: mediaIds,
+            tagged_user_ids: taggedUserIds
+          }
+        },
+        ...placeId && {
+          geo: {
+            place_id: placeId
+          }
+        }
+      },
+      fallbackError: ACTION_ERROR_MESSAGE
+    };
+    const response = await this.app.createTweet(params);
+    $.export(
+      "$summary",
+      `Successfully posted tweet (ID ${response.data?.id})`
+    );
+    return response;
+  }
 });
+export {
+  create_tweet_default as default
+};