@pipedream/twitter 2.3.2 → 2.3.4

package/dist/sources/common/base.mjs

@@ -1,78 +1,555 @@
+// components/twitter/sources/common/base.ts
 import { DEFAULT_POLLING_SOURCE_TIMER_INTERVAL } from "@pipedream/platform";
-import common from "../../common/appValidation.mjs";
-import { ERROR_MESSAGE } from "../../common/errorMessage.mjs";
-export default {
-    ...common,
-    props: {
-        ...common.props,
-        db: "$.service.db",
-        timer: {
-            type: "$.interface.timer",
-            default: {
-                intervalSeconds: DEFAULT_POLLING_SOURCE_TIMER_INTERVAL,
-            },
-        },
+
+// 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
     },
-    hooks: {
-        async deploy() {
-            const q = "Pipedream";
-            const data = await this.getRecentTweets({
-                params: {
-                    query: q,
-                },
-                validateStatus: () => true,
-            });
-            this.app.throwError(data);
-            await this.getAndProcessData();
-        },
+    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
+        })) ?? [];
+      }
     },
-    methods: {
-        ...common.methods,
-        getEntityName() {
-            return "Entity";
-        },
-        getItemSummary() {
-            throw new Error("getItemSummary() not implemented in component");
-        },
-        async getResources() {
-            throw new Error("getResources() not implemented in component");
-        },
-        getSavedIds() {
-            return this.db.get("savedEntityIds");
-        },
-        setSavedIds(data) {
-            this.db.set("savedEntityIds", data);
-        },
-        async getAndProcessData(maxResults) {
-            const data = await this.getResources(maxResults);
-            if (data) {
-                const savedIds = this.getSavedIds() ?? [];
-                data
-                    .filter(({ id }) => !savedIds.includes(id))
-                    .reverse()
-                    .forEach((obj) => {
-                    this.emitEvent(obj);
-                    savedIds.push(obj.id);
-                });
-                this.setSavedIds(savedIds);
-            }
-        },
-        emitEvent(data) {
-            const ts = Date.now();
-            const { id } = data;
-            this.$emit(data, {
-                id,
-                summary: `New ${this.getEntityName()}: "${this.getItemSummary(data)}"`,
-                ts,
-            });
-        },
+    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,
     },
-    async run() {
+    */
+    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 {
-            await this.getAndProcessData(50);
+          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
+          ]);
         }
-        catch (err) {
-            throw new Error(`${ERROR_MESSAGE} Error response: ${JSON.stringify(err)}`);
+        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/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/sources/common/base.ts
+var base_default = {
+  ...appValidation_default,
+  props: {
+    ...appValidation_default.props,
+    db: "$.service.db",
+    timer: {
+      type: "$.interface.timer",
+      default: {
+        intervalSeconds: DEFAULT_POLLING_SOURCE_TIMER_INTERVAL
+      }
+    }
+  },
+  hooks: {
+    async deploy() {
+      const q = "Pipedream";
+      const data = await this.getRecentTweets({
+        params: {
+          query: q
+        },
+        validateStatus: () => true
+      });
+      this.app.throwError(data);
+      await this.getAndProcessData();
+    }
+  },
+  methods: {
+    ...appValidation_default.methods,
+    getEntityName() {
+      return "Entity";
+    },
+    getItemSummary() {
+      throw new Error("getItemSummary() not implemented in component");
+    },
+    async getResources() {
+      throw new Error("getResources() not implemented in component");
+    },
+    getSavedIds() {
+      return this.db.get("savedEntityIds");
+    },
+    setSavedIds(data) {
+      this.db.set("savedEntityIds", data);
+    },
+    async getAndProcessData(maxResults) {
+      const data = await this.getResources(maxResults);
+      if (data) {
+        const savedIds = this.getSavedIds() ?? [];
+        data.filter(({ id }) => !savedIds.includes(id)).reverse().forEach((obj) => {
+          this.emitEvent(obj);
+          savedIds.push(obj.id);
+        });
+        this.setSavedIds(savedIds);
+      }
+    },
+    emitEvent(data) {
+      const ts = Date.now();
+      const { id } = data;
+      this.$emit(data, {
+        id,
+        summary: `New ${this.getEntityName()}: "${this.getItemSummary(data)}"`,
+        ts
+      });
+    }
+  },
+  async run() {
+    try {
+      await this.getAndProcessData(50);
+    } catch (err) {
+      throw new Error(`${ERROR_MESSAGE} Error response: ${JSON.stringify(err)}`);
+    }
+  }
+};
+export {
+  base_default as default
 };

package/dist/sources/common/cacheUserId.mjs

@@ -1,18 +1,35 @@
-import { getUserId } from "../../common/methods.mjs";
+// components/twitter/common/methods.ts
+import { ConfigurationError } from "@pipedream/platform";
+async function getUserId() {
+  let { userNameOrId: id } = this;
+  if (id === "me" || id === void 0) {
+    id = await this.app.getAuthenticatedUserId();
+  } else if (id.startsWith("@")) {
+    const userData = await this.app.getUserByUsername(id.slice(1));
+    id = userData?.data?.id;
+    if (!id) throw new ConfigurationError("**User not found!** Check the `User Name or ID` prop.");
+  }
+  return id;
+}
+
+// components/twitter/sources/common/cacheUserId.ts
 async function getCachedUserId() {
-    const { userNameOrId: name } = this;
-    const cache = this.db.get("cachedUser");
-    if (cache?.name === name) {
-        return cache.id;
-    }
-    const id = await this.getUserId();
-    this.db.set("cachedUser", {
-        id,
-        name,
-    });
-    return id;
+  const { userNameOrId: name } = this;
+  const cache = this.db.get("cachedUser");
+  if (cache?.name === name) {
+    return cache.id;
+  }
+  const id = await this.getUserId();
+  this.db.set("cachedUser", {
+    id,
+    name
+  });
+  return id;
 }
-export default {
-    getCachedUserId,
-    getUserId,
+var cacheUserId_default = {
+  getCachedUserId,
+  getUserId
+};
+export {
+  cacheUserId_default as default
 };

package/dist/sources/common/getItemSummary.mjs

@@ -1,12 +1,16 @@
-const SUMMARY_TEXT_MAX_LENGTH = 30;
-export function getListSummary({ name }) {
-    return name;
+// components/twitter/sources/common/getItemSummary.ts
+var SUMMARY_TEXT_MAX_LENGTH = 30;
+function getListSummary({ name }) {
+  return name;
 }
-export function getTweetSummary({ text }) {
-    return text.length > SUMMARY_TEXT_MAX_LENGTH
-        ? text.slice(0, SUMMARY_TEXT_MAX_LENGTH) + "..."
-        : text;
+function getTweetSummary({ text }) {
+  return text.length > SUMMARY_TEXT_MAX_LENGTH ? text.slice(0, SUMMARY_TEXT_MAX_LENGTH) + "..." : text;
 }
-export function getUserSummary({ username }) {
-    return username;
+function getUserSummary({ username }) {
+  return username;
 }
+export {
+  getListSummary,
+  getTweetSummary,
+  getUserSummary
+};