@pipedream/twitter 0.3.10 → 1.0.0

package/sources/my-liked-tweets/my-liked-tweets.mjs

@@ -1,30 +0,0 @@
-import twitter from "../../twitter.app.mjs";
-import { DEFAULT_POLLING_SOURCE_TIMER_INTERVAL } from "@pipedream/platform";
-
-export default {
-  key: "twitter-my-liked-tweets",
-  name: "My Liked Tweets",
-  description: "Emit new Tweets you like on Twitter",
-  version: "0.0.10",
-  type: "source",
-  props: {
-    twitter,
-    timer: {
-      label: "Polling interval",
-      description: "Pipedream will poll the Twitter API on this schedule",
-      type: "$.interface.timer",
-      default: {
-        intervalSeconds: DEFAULT_POLLING_SOURCE_TIMER_INTERVAL,
-      },
-    },
-  },
-  dedupe: "unique",
-  async run() {
-    (await this.twitter.getLikedTweets()).reverse().forEach((tweet) => {
-      this.$emit(this.twitter.enrichTweet(tweet), {
-        id: tweet.id_str,
-        summary: tweet.full_text,
-      });
-    });
-  },
-};

package/sources/my-tweets/my-tweets.mjs

@@ -1,48 +0,0 @@
-import base from "../common/tweets.mjs";
-
-export default {
-  ...base,
-  key: "twitter-my-tweets",
-  name: "My Tweets",
-  description: "Emit new Tweets you post to Twitter",
-  version: "0.0.12",
-  type: "source",
-  props: {
-    ...base.props,
-    includeRetweets: {
-      propDefinition: [
-        base.props.twitter,
-        "includeRetweets",
-      ],
-    },
-    includeReplies: {
-      propDefinition: [
-        base.props.twitter,
-        "includeReplies",
-      ],
-    },
-  },
-  methods: {
-    ...base.methods,
-    shouldExcludeReplies() {
-      return this.includeReplies === "exclude";
-    },
-    shouldIncludeRetweets() {
-      return this.includeRetweets !== "exclude";
-    },
-    async getScreenName() {
-      const { screen_name: screenName } = await this.twitter.verifyCredentials();
-      return screenName;
-    },
-    async retrieveTweets() {
-      const screenName = await this.getScreenName();
-      return this.twitter.getUserTimeline({
-        screenName,
-        count: this.count,
-        sinceId: this.getSinceId(),
-        excludeReplies: this.shouldExcludeReplies(),
-        includeRts: this.shouldIncludeRetweets(),
-      });
-    },
-  },
-};

package/sources/new-follower-of-me/new-follower-of-me.mjs

@@ -1,69 +0,0 @@
-import common from "../common/followers.mjs";
-
-export default {
-  ...common,
-  key: "twitter-new-follower-of-me",
-  name: "New Follower of Me",
-  description: "Emit new event when a user follows you on Twitter",
-  version: "0.0.12",
-  type: "source",
-  props: {
-    ...common.props,
-    followersCacheSize: {
-      type: "integer",
-      label: "Followers Cache Size",
-      description: "The maximum amount of follower ID's that will be cached at any given time",
-      min: 10,
-      max: 100,
-      default: 100,
-    },
-  },
-  methods: {
-    ...common.methods,
-    _getHasExecuted() {
-      return this.db.get("hasExecuted");
-    },
-    _setHasExecuted(hasExecuted) {
-      this.db.set("hasExecuted", hasExecuted);
-    },
-    _wasComponentExecuted() {
-      return !!this._getHasExecuted();
-    },
-    _markComponentAsExecuted() {
-      this._setHasExecuted(true);
-    },
-    getFollowersCacheSize() {
-      return this.followersCacheSize;
-    },
-    async getRelevantIds() {
-      const mostRecentFollowers = this.getFollowersCache();
-      if (!this._wasComponentExecuted()) {
-        this._markComponentAsExecuted();
-
-        // The first time this event source is executed, it will emit an event
-        // for the most recent followers.
-        // We reverse the list of new followers so that the event source emits the
-        // events for each follower in the same order that the followers followed
-        // the account, from least to most recent.
-        return mostRecentFollowers.reverse();
-      }
-
-      const newFollowersGen = this.scanNewFollowers(mostRecentFollowers);
-      const newFollowers = [];
-      for await (const id of newFollowersGen) {
-        newFollowers.push(id);
-      }
-
-      const followersCache = [
-        ...newFollowers,
-        ...mostRecentFollowers,
-      ];
-      this.setFollowersCache(followersCache);
-
-      // We reverse the list of new followers so that the event source emits the
-      // events for each follower in the same order that the followers followed
-      // the account, from least to most recent.
-      return newFollowers.reverse();
-    },
-  },
-};

package/sources/new-follower-of-user/new-follower-of-user.mjs

@@ -1,25 +0,0 @@
-import base from "../new-follower-of-me/new-follower-of-me.mjs";
-
-export default {
-  ...base,
-  key: "twitter-new-follower-of-user",
-  name: "New Follower of User",
-  description: "Emit new event when a specific user gains a follower",
-  version: "0.0.12",
-  type: "source",
-  props: {
-    ...base.props,
-    screenName: {
-      propDefinition: [
-        base.props.twitter,
-        "screenName",
-      ],
-    },
-  },
-  methods: {
-    ...base.methods,
-    getScreenName() {
-      return this.screenName;
-    },
-  },
-};

package/sources/new-list-followed/new-list-followed.mjs

@@ -1,24 +0,0 @@
-import common from "../common/followed.mjs";
-
-export default {
-  ...common,
-  key: "twitter-new-list-followed",
-  name: "New List Followed",
-  description: "Emit new event when the authenticated user follows a List",
-  version: "0.0.4",
-  type: "source",
-  dedupe: "unique",
-  methods: {
-    ...common.methods,
-    async getFollowed() {
-      return this.twitter.getLists({});
-    },
-    generateMeta(list) {
-      return {
-        id: list.id,
-        summary: list.name,
-        ts: Date.now(),
-      };
-    },
-  },
-};

package/sources/new-trends-by-geo/new-trends-by-geo.mjs

@@ -1,40 +0,0 @@
-import twitter from "../../twitter.app.mjs";
-import { DEFAULT_POLLING_SOURCE_TIMER_INTERVAL } from "@pipedream/platform";
-
-export default {
-  key: "twitter-new-trends-by-geo",
-  name: "New Trends by Geo",
-  description: "Emit new event when a new topic is trending on Twitter in a specific geographic location",
-  version: "0.0.10",
-  type: "source",
-  props: {
-    twitter,
-    trendLocation: {
-      propDefinition: [
-        twitter,
-        "trendLocation",
-      ],
-    },
-    timer: {
-      label: "Polling interval",
-      description: "Pipedream will poll the Twitter API on this schedule",
-      type: "$.interface.timer",
-      default: {
-        intervalSeconds: DEFAULT_POLLING_SOURCE_TIMER_INTERVAL,
-      },
-    },
-  },
-  dedupe: "unique",
-  async run() {
-    (await this.twitter.getTrends({
-      id: this.trendLocation,
-    })).forEach((geo) => {
-      geo.trends.reverse().forEach((trend) => {
-        this.$emit(trend, {
-          id: trend.query,
-          summary: trend.name,
-        });
-      });
-    });
-  },
-};

package/sources/new-tweet-in-list/new-tweet-in-list.mjs

@@ -1,49 +0,0 @@
-import base from "../common/tweets.mjs";
-
-export default {
-  ...base,
-  key: "twitter-new-tweet-in-list",
-  name: "New Tweet in List",
-  description: "Emit new Tweets posted by members of a list",
-  version: "0.0.8",
-  type: "source",
-  props: {
-    ...base.props,
-    includeRetweets: {
-      propDefinition: [
-        base.props.twitter,
-        "includeRetweets",
-      ],
-    },
-    list: {
-      propDefinition: [
-        base.props.twitter,
-        "list",
-      ],
-    },
-    includeEntities: {
-      type: "boolean",
-      label: "Entities",
-      description: `
-        Include the 'entities' node, which offers a variety of metadata about the
-        tweet in a discreet structure, including: user_mentions, urls, and hashtags
-      `,
-      default: false,
-    },
-  },
-  methods: {
-    ...base.methods,
-    shouldIncludeRetweets() {
-      return this.includeRetweets !== "exclude";
-    },
-    retrieveTweets() {
-      return this.twitter.getListTweets({
-        listId: this.list,
-        count: this.count,
-        sinceId: this.getSinceId(),
-        includeEntities: this.includeEntities,
-        includeRetweets: this.shouldIncludeRetweets(),
-      });
-    },
-  },
-};

package/sources/new-unfollower-of-me/new-unfollower-of-me.mjs

@@ -1,16 +0,0 @@
-import common from "../common/followers.mjs";
-
-export default {
-  ...common,
-  key: "twitter-new-unfollower-of-me",
-  name: "New Unfollower of Me",
-  description: "Emit new event when a user unfollows you on Twitter",
-  version: "0.0.13",
-  type: "source",
-  methods: {
-    ...common.methods,
-    getRelevantIds() {
-      return this.getUnfollowers();
-    },
-  },
-};

package/sources/new-unfollower-of-user/new-unfollower-of-user.mjs

@@ -1,25 +0,0 @@
-import base from "../new-unfollower-of-me/new-unfollower-of-me.mjs";
-
-export default {
-  ...base,
-  key: "twitter-new-unfollower-of-user",
-  name: "New Unfollower of User",
-  description: "Emit new event when a specific user loses a follower on Twitter",
-  version: "0.0.11",
-  type: "source",
-  props: {
-    ...base.props,
-    screenName: {
-      propDefinition: [
-        base.props.twitter,
-        "screenName",
-      ],
-    },
-  },
-  methods: {
-    ...base.methods,
-    getScreenName() {
-      return this.screenName;
-    },
-  },
-};

package/sources/new-user-followed/new-user-followed.mjs

@@ -1,25 +0,0 @@
-import common from "../common/followed.mjs";
-
-export default {
-  ...common,
-  key: "twitter-new-user-followed",
-  name: "New User Followed",
-  description: "Emit new event when the authenticated user follows a User",
-  version: "0.0.4",
-  type: "source",
-  dedupe: "unique",
-  methods: {
-    ...common.methods,
-    async getFollowed() {
-      const { users } = await this.twitter.getUserFollows({});
-      return users;
-    },
-    generateMeta(user) {
-      return {
-        id: user.id,
-        summary: user.name,
-        ts: Date.now(),
-      };
-    },
-  },
-};

package/sources/search-mentions/search-mentions.mjs

@@ -1,144 +0,0 @@
-import twitter from "../../twitter.app.mjs";
-import moment from "moment";
-import { DEFAULT_POLLING_SOURCE_TIMER_INTERVAL } from "@pipedream/platform";
-
-export default {
-  key: "twitter-search-mentions",
-  name: "Search Mentions",
-  description: "Emit new Tweets that match your search criteria",
-  version: "0.0.10",
-  type: "source",
-  props: {
-    db: "$.service.db",
-    twitter,
-    q: {
-      propDefinition: [
-        twitter,
-        "q",
-      ],
-    },
-    resultType: {
-      propDefinition: [
-        twitter,
-        "resultType",
-      ],
-    },
-    includeRetweets: {
-      propDefinition: [
-        twitter,
-        "includeRetweets",
-      ],
-    },
-    includeReplies: {
-      propDefinition: [
-        twitter,
-        "includeReplies",
-      ],
-    },
-    lang: {
-      propDefinition: [
-        twitter,
-        "lang",
-      ],
-    },
-    locale: {
-      propDefinition: [
-        twitter,
-        "locale",
-      ],
-    },
-    geocode: {
-      propDefinition: [
-        twitter,
-        "geocode",
-      ],
-    },
-    enrichTweets: {
-      propDefinition: [
-        twitter,
-        "enrichTweets",
-      ],
-    },
-    count: {
-      propDefinition: [
-        twitter,
-        "count",
-      ],
-    },
-    maxRequests: {
-      propDefinition: [
-        twitter,
-        "maxRequests",
-      ],
-    },
-    timer: {
-      label: "Polling interval",
-      description: "Pipedream will poll the Twitter API on this schedule",
-      type: "$.interface.timer",
-      default: {
-        intervalSeconds: DEFAULT_POLLING_SOURCE_TIMER_INTERVAL,
-      },
-    },
-  },
-  methods: {
-    _getSinceId() {
-      return this.db.get("sinceId");
-    },
-    _setSinceId(sinceId) {
-      this.db.set("sinceId", sinceId);
-    },
-  },
-  async run() {
-    const sinceId = this._getSinceId();
-    const {
-      lang,
-      locale,
-      geocode,
-      resultType,
-      enrichTweets,
-      includeReplies,
-      includeRetweets,
-      maxRequests,
-      count,
-      q,
-    } = this;
-    let maxId;
-    const limitFirstPage = !sinceId;
-
-    // run paginated search
-    const tweets = await this.twitter.paginatedSearch({
-      q,
-      sinceId,
-      lang,
-      locale,
-      geocode,
-      resultType,
-      enrichTweets,
-      includeReplies,
-      includeRetweets,
-      maxRequests,
-      count,
-      limitFirstPage,
-    });
-
-    // emit array of tweet objects
-    if (tweets.length > 0) {
-      tweets.sort(function (a, b) { return a.id - b.id; });
-
-      tweets.forEach((tweet) => {
-        this.$emit(tweet, {
-          ts: moment(tweet.created_at, "ddd MMM DD HH:mm:ss Z YYYY").valueOf(),
-          summary: tweet.full_text || tweet.text,
-          id: tweet.id_str,
-        });
-
-        if (tweet.id_str > maxId || !maxId) {
-          maxId = tweet.id_str;
-        }
-      });
-    }
-    if (maxId) {
-      this._setSinceId(maxId);
-    }
-  },
-};

package/sources/tweets-liked-by-user/tweets-liked-by-user.mjs

@@ -1,38 +0,0 @@
-import twitter from "../../twitter.app.mjs";
-import { DEFAULT_POLLING_SOURCE_TIMER_INTERVAL } from "@pipedream/platform";
-
-export default {
-  key: "twitter-tweets-liked-by-user",
-  name: "Tweet Liked by User",
-  description: "Emit new Tweets liked by a specific user on Twitter",
-  version: "0.0.10",
-  type: "source",
-  props: {
-    twitter,
-    screenName: {
-      propDefinition: [
-        twitter,
-        "screenName",
-      ],
-    },
-    timer: {
-      label: "Polling interval",
-      description: "Pipedream will poll the Twitter API on this schedule",
-      type: "$.interface.timer",
-      default: {
-        intervalSeconds: DEFAULT_POLLING_SOURCE_TIMER_INTERVAL,
-      },
-    },
-  },
-  dedupe: "unique",
-  async run() {
-    (await this.twitter.getLikedTweets({
-      screenName: this.screen_name,
-    })).reverse().forEach((tweet) => {
-      this.$emit(this.twitter.enrichTweet(tweet), {
-        id: tweet.id_str,
-        summary: tweet.full_text,
-      });
-    });
-  },
-};

package/sources/user-tweets/user-tweets.mjs

@@ -1,49 +0,0 @@
-import base from "../common/tweets.mjs";
-
-export default {
-  ...base,
-  key: "twitter-user-tweets",
-  name: "User Tweets",
-  description: "Emit new Tweets posted by a user",
-  version: "0.0.12",
-  type: "source",
-  props: {
-    ...base.props,
-    screenName: {
-      propDefinition: [
-        base.props.twitter,
-        "screenName",
-      ],
-    },
-    includeRetweets: {
-      propDefinition: [
-        base.props.twitter,
-        "includeRetweets",
-      ],
-    },
-    includeReplies: {
-      propDefinition: [
-        base.props.twitter,
-        "includeReplies",
-      ],
-    },
-  },
-  methods: {
-    ...base.methods,
-    shouldExcludeReplies() {
-      return this.includeReplies === "exclude";
-    },
-    shouldIncludeRetweets() {
-      return this.includeRetweets !== "exclude";
-    },
-    retrieveTweets() {
-      return this.twitter.getUserTimeline({
-        screenName: this.screenName,
-        count: this.count,
-        sinceId: this.getSinceId(),
-        excludeReplies: this.shouldExcludeReplies(),
-        includeRts: this.shouldIncludeRetweets(),
-      });
-    },
-  },
-};

package/sources/watch-retweets-of-me/watch-retweets-of-me.mjs

@@ -1,36 +0,0 @@
-import base from "../common/tweets.mjs";
-
-export default {
-  ...base,
-  key: "twitter-watch-retweets-of-me",
-  name: "Watch Retweets of Me",
-  version: "0.0.8",
-  description: "Emit new event when recent Tweets authored by the authenticating user that have been retweeted by others",
-  type: "source",
-  props: {
-    ...base.props,
-    includeEntities: {
-      propDefinition: [
-        base.props.twitter,
-        "includeEntities",
-      ],
-    },
-    includeUserEntities: {
-      propDefinition: [
-        base.props.twitter,
-        "includeUserEntities",
-      ],
-    },
-  },
-  methods: {
-    ...base.methods,
-    retrieveTweets() {
-      return this.twitter.getRetweetsOfMe({
-        count: this.count,
-        sinceId: this.getSinceId(),
-        includeEntities: this.includeEntities,
-        includeUserEntities: this.includeUserEntities,
-      });
-    },
-  },
-};

package/sources/watch-retweets-of-my-tweet/watch-retweets-of-my-tweet.mjs

@@ -1,44 +0,0 @@
-import base from "../common/tweets.mjs";
-
-export default {
-  ...base,
-  key: "twitter-watch-retweets-of-my-tweet",
-  name: "Watch Retweets of My Tweet",
-  description: "Emit new event when a specific Tweet from the authenticated user is retweeted",
-  version: "0.0.7",
-  type: "source",
-  props: {
-    ...base.props,
-    tweetId: {
-      type: "string",
-      label: "Tweet",
-      description: "The Tweet to watch for retweets",
-      options(context) {
-        return this.tweetIdOptions(context);
-      },
-    },
-  },
-  methods: {
-    ...base.methods,
-    async getScreenName() {
-      const { screen_name: screenName } = await this.twitter.verifyCredentials();
-      return screenName;
-    },
-    generateMeta(tweet) {
-      const baseMeta = base.methods.generateMeta.bind(this)(tweet);
-      const { screen_name: screenName = "N/A" } = tweet.user;
-      const summary = `Retweet by @${screenName}`;
-      return {
-        ...baseMeta,
-        summary,
-      };
-    },
-    retrieveTweets() {
-      return this.twitter.getRetweets({
-        id: this.tweetId,
-        count: this.count,
-        sinceId: this.getSinceId(),
-      });
-    },
-  },
-};