@pipedream/twitter 0.3.1 → 0.3.4

package/sources/common-followers.js

@@ -1,99 +0,0 @@
-const twitter = require("../twitter.app");
-
-module.exports = {
-  dedupe: "unique",
-  props: {
-    db: "$.service.db",
-    twitter,
-    timer: {
-      type: "$.interface.timer",
-      default: {
-        intervalSeconds: 60 * 15,
-      },
-    },
-  },
-  hooks: {
-    async activate() {
-      const followers = this.db.get("followers") || [];
-      if (followers.length > 0) {
-        console.log(`
-          Followers cache already set. Skipping initial provisioning.
-        `);
-        return;
-      }
-
-      const screenName = this.getScreenName();
-      const followerIds = this.twitter.getAllFollowers(screenName);
-      for await (const id of followerIds) {
-        followers.push(id);
-      }
-      this.db.set("followers", followers);
-      console.log(`
-        Provisioned followers cache: found ${followers.length} records
-      `);
-    },
-  },
-  methods: {
-    getScreenName() {
-      // When screen name is not explicitly provided, the Twitter API defaults
-      // it to the user making the API request
-      return undefined;
-    },
-    getRelevantIds() {
-      return [];
-    },
-    generateMeta(data) {
-      const {
-        timestamp,
-        user,
-      } = data;
-      const {
-        id_str: id,
-        screen_name: summary,
-      } = user;
-      // Event timestamp is expressed in seconds, whereas Javascript timestamps
-      // are expressed in milliseconds
-      const ts = timestamp * 1000;
-      return {
-        id,
-        summary,
-        ts,
-      };
-    },
-    async pullFollowers() {
-      const screenName = this.getScreenName();
-      const followerIdsGen = this.twitter.getAllFollowers(screenName);
-      const result = [];
-      for await (const id of followerIdsGen) {
-        result.push(id);
-      }
-      return result;
-    },
-    async getUnfollowers() {
-      const prevFollowers = this.db.get("followers");
-      const currFollowers = await this.pullFollowers();
-      this.db.set("followers", currFollowers);
-
-      const currFollowersSet = new Set(currFollowers);
-      return prevFollowers.filter(pf => !currFollowersSet.has(pf));
-    },
-  },
-  async run(event) {
-    const { timestamp } = event;
-    const relevantIds = await this.getRelevantIds();
-    if (relevantIds.length <= 0) {
-      console.log('Follower data remains unchanged');
-      return;
-    }
-
-    const users = await this.twitter.lookupUsers(relevantIds);
-    users.forEach(user => {
-      const data = {
-        timestamp,
-        user,
-      };
-      const meta = this.generateMeta(data);
-      this.$emit(user, meta);
-    });
-  },
-}

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

@@ -1,26 +0,0 @@
-const twitter = require('../../twitter.app.js')
-
-module.exports = { 
-  key: "twitter-my-liked-tweets",
-  name: "My Liked Tweets", 
-  description: "Emit new Tweets you like on Twitter", 
-  version: "0.0.1",
-  props: {
-    twitter,
-    timer: {
-      type: "$.interface.timer",
-      default: {
-        intervalSeconds: 60 * 15,
-      },
-    },
-  },
-  dedupe: "unique",
-  async run(event) {     
-    (await this.twitter.getLikedTweets()).reverse().forEach(tweet => {
-      this.$emit(tweet, {
-        id: tweet.id_str,
-        summary: tweet.full_text,
-      })
-    })
-  },
-}

package/sources/my-tweets/my-tweets.js

@@ -1,83 +0,0 @@
-const twitter = require('../../twitter.app.js')
-const moment = require('moment')
- 
-module.exports = { 
-  key: "twitter-my-tweets",
-  name: "My Tweets",
-  description: "Emit new Tweets you post to Twitter", 
-  version: "0.0.1",
-  props: {
-    db: "$.service.db",
-    twitter,
-    q: { propDefinition: [twitter, "keyword_filter"] },
-    result_type: { propDefinition: [twitter, "result_type"] },
-    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: {
-      type: "$.interface.timer",
-      default: {
-        intervalSeconds: 60 * 15,
-      },
-    },
-  },
-  async run(event) {
-    const account = await this.twitter.verifyCredentials()
-    const from = `from:${account.screen_name}`
-    const since_id = this.db.get("since_id")
-    const { lang, locale, geocode, result_type, enrichTweets, includeReplies, includeRetweets, maxRequests, count } = this
-    let q = from, max_id, limitFirstPage
-    
-    // join "from" filter and search keywords
-    if (this.q) {
-      q += ` ${this.q}`
-    }
-
-    if (!since_id) {
-      limitFirstPage = true
-    } else {
-      limitFirstPage = false
-    }
-
-    // run paginated search
-    const tweets = await this.twitter.paginatedSearch({ 
-      q, 
-      since_id, 
-      lang, 
-      locale, 
-      geocode, 
-      result_type, 
-      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 > max_id || !max_id) {
-          max_id = tweet.id_str
-        }
-      })
-    } 
-    if (max_id) {
-      this.db.set("since_id", max_id)
-    }
-  },
-}

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

@@ -1,68 +0,0 @@
-const twitter = require('../../twitter.app.js')
-
-module.exports = { 
-  key: "twitter-new-follower-of-me",
-  name: "New Follower of Me", 
-  description: "Emit an event when a user follows you on Twitter", 
-  version: "0.0.1",
-  props: {
-    db: "$.service.db",
-    twitter,
-    timer: {
-      type: "$.interface.timer",
-      default: {
-        intervalSeconds: 60 * 15,
-      },
-    },
-  },
-  async run(event) {     
-    const cached = this.db.get("followers") || []
-    const activation = this.db.get("activation") || true
-    let newFollowers = []
-    const followers = (await this.twitter.getFollowers())
-    const latest = [...followers]
-    if (JSON.stringify(latest) === JSON.stringify(cached)) {
-      console.log('No new followers')
-    } else {
-      let lastDeleted
-      let lastGapIndex
-      for (let i = 0; i < cached.length; i++) {
-        if(latest.includes(cached[i])) {
-          delete latest[latest.indexOf(cached[i])]
-          if (i - 1 !== lastDeleted) {
-            //new gap detected
-            lastGapIndex = i
-          }
-          lastDeleted = i
-        }
-      }
-
-      if (lastGapIndex >= 0) {
-        latest.length = lastGapIndex + 1
-      }
-
-      // filter out any deleted elements
-      newFollowers = latest.filter(() => true)
-
-      // emit up to the most recent 100 followers on the first execution to use for test events
-      if (activation && newFollowers.length > 100) {
-        newFollowers = newFollowers.slice(0, 100)
-      }
-
-      if (newFollowers.length > 0) {
-        (await this.twitter.lookupUsers(newFollowers)).reverse().forEach(user => {
-          this.$emit(user,{
-            summary: user.screen_name,
-            id: user.id_str,
-          })
-        })
-      } else {
-        console.log('No new followers')
-      }
-
-      // set the checkpoint to the full set of followers from the last step
-      this.db.set("followers", followers)
-      this.db.set("activation", false) 
-    }
-  },
-}

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

@@ -1,69 +0,0 @@
-const twitter = require('../../twitter.app.js')
-
-module.exports = { 
-  key: "twitter-new-follower-of-user",
-  name: "New Follower of User",
-  description: "Emit an event when a specific user gains a follower",  
-  version: "0.0.1",
-  props: {
-    db: "$.service.db",
-    twitter,
-    screen_name: { propDefinition: [twitter, "screen_name"] },
-    timer: {
-      type: "$.interface.timer",
-      default: {
-        intervalSeconds: 60 * 15,
-      },
-    },
-  },
-  async run(event) {     
-    const cached = this.db.get("followers") || []
-    const activation = this.db.get("activation") || true
-    let newFollowers = []
-    const followers = (await this.twitter.getFollowers(this.screen_name))
-    const latest = [...followers]
-    if (JSON.stringify(latest) === JSON.stringify(cached)) {
-      console.log('No new followers')
-    } else {
-      let lastDeleted
-      let lastGapIndex
-      for (let i = 0; i < cached.length; i++) {
-        if(latest.includes(cached[i])) {
-          delete latest[latest.indexOf(cached[i])]
-          if (i - 1 !== lastDeleted) {
-            //new gap detected
-            lastGapIndex = i
-          }
-          lastDeleted = i
-        }
-      }
-
-      if (lastGapIndex >= 0) {
-        latest.length = lastGapIndex + 1
-      }
-
-      // filter out any deleted elements
-      newFollowers = latest.filter(() => true)
-
-      // emit up to the most recent 100 followers on the first execution to use for test events
-      if (activation && newFollowers.length > 100) {
-        newFollowers = newFollowers.slice(0, 100)
-      }
-
-      if (newFollowers.length > 0) {
-        (await this.twitter.lookupUsers(newFollowers)).reverse().forEach(user => {
-          this.$emit(user,{
-            summary: user.screen_name,
-            id: user.id_str,
-          })
-        })
-      } else {
-        console.log('No new followers')
-      }
-
-      // set the checkpoint to the full set of followers from the last step
-      this.db.set("followers", followers)
-      this.db.set("activation", false)
-    }
-  },
-}

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

@@ -1,29 +0,0 @@
-const twitter = require('../../twitter.app.js')
-
-module.exports = { 
-  key: "twitter-new-trends-by-geo",
-  name: "New Trends by Geo", 
-  description: "Emit an event when a new topic is trending on Twitter in a specific geographic location", 
-  version: "0.0.1",
-  props: {
-    twitter,
-    trendLocation: { propDefinition: [twitter, "trendLocation"] },
-    timer: {
-      type: "$.interface.timer",
-      default: {
-        intervalSeconds: 60 * 15,
-      },
-    },
-  },
-  dedupe: "unique",
-  async run(event) {     
-    const response = (await this.twitter.getTrends()).forEach(geo => {
-      geo.trends.reverse().forEach(trend => {
-        this.$emit(trend, {
-          id: trend.query,
-          summary: trend.name,
-        })
-      })
-    })
-  },
-}

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

@@ -1,22 +0,0 @@
-const common = require("../common-followers");
-
-module.exports = {
-  ...common,
-  key: "twitter-new-unfollower-of-user",
-  name: "New Unfollower of User",
-  description: "Emit an event when a specific user loses a follower on Twitter",
-  version: "0.0.1",
-  props: {
-    ...common.props,
-    screen_name: { propDefinition: [common.twitter, "screen_name"] },
-  },
-  methods: {
-    ...common.methods,
-    getScreenName() {
-      return this.screen_name;
-    },
-    getRelevantIds() {
-      return this.getUnfollowers();
-    },
-  },
-};

package/sources/search-mentions/search-mentions.js

@@ -1,76 +0,0 @@
-const twitter = require('../../twitter.app.js')
-const moment = require('moment')
- 
-module.exports = {
-  key: "twitter-search-mentions",
-  name: "Search Mentions",
-  description: "Emit new Tweets that matches your search criteria", 
-  version: "0.0.1",
-  props: {
-    db: "$.service.db",
-    twitter,
-    q: { propDefinition: [twitter, "q"] },
-    result_type: { propDefinition: [twitter, "result_type"] },
-    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: {
-      type: "$.interface.timer",
-      default: {
-        intervalSeconds: 60 * 15,
-      },
-    }, 
-  }, 
-  async run(event) {
-    const since_id = this.db.get("since_id")
-    const { lang, locale, geocode, result_type, enrichTweets, includeReplies, includeRetweets, maxRequests, count } = this
-    let q = this.q, max_id, limitFirstPage
-
-    if (!since_id) {
-      limitFirstPage = true
-    } else {
-      limitFirstPage = false
-    }
- 
-    // run paginated search
-    const tweets = await this.twitter.paginatedSearch({ 
-      q, 
-      since_id, 
-      lang, 
-      locale, 
-      geocode, 
-      result_type, 
-      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 > max_id || !max_id) {
-          max_id = tweet.id_str
-        }
-      })
-    }
-    if (max_id) {
-      this.db.set("since_id", max_id)
-    }
-  },
-}

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

@@ -1,27 +0,0 @@
-const twitter = require('../../twitter.app.js')
-
-module.exports = { 
-  key: "twitter-tweet-liked-by-user",
-  name: "Tweet Liked by User",
-  description: "Emit new Tweets liked by a specific user on Twitter", 
-  version: "0.0.1",
-  props: {
-    twitter,
-    screen_name: { propDefinition: [twitter, "screen_name"] },
-    timer: {
-      type: "$.interface.timer",
-      default: {
-        intervalSeconds: 60 * 15,
-      },
-    },
-  },
-  dedupe: "unique",
-  async run(event) {     
-    (await this.twitter.getLikedTweets({ screen_name: this.screen_name })).reverse().forEach(tweet => {
-      this.$emit(tweet, {
-        id: tweet.id_str,
-        summary: tweet.full_text,
-      })
-    })
-  },
-}

package/sources/user-tweets/user-tweets.js

@@ -1,66 +0,0 @@
-const twitter = require('../../twitter.app.js')
-const moment = require('moment')
-
-module.exports = {
-  key: "twitter-user-tweets",
-  name: "User Tweets",
-  description: "Emit new Tweets posted by a user", 
-  version: "0.0.1",
-  props: { 
-    db: "$.service.db",
-    twitter,
-    screen_name: { propDefinition: [twitter, "screen_name"] }, 
-    include_rts: { propDefinition: [twitter, "includeRetweets"] },
-    includeReplies: { propDefinition: [twitter, "includeReplies"] },
-    enrichTweets: { propDefinition: [twitter, "enrichTweets"] },
-    count: { propDefinition: [twitter, "count"] },
-    timer: {
-      type: "$.interface.timer",
-      default: {
-        intervalSeconds: 60 * 15,
-      },
-    },
-  }, 
-  methods: {},
-  async run(event) {
-    const screen_name = this.screen_name //.replace('@','')
-    const since_id = this.db.get("since_id")
-    const { enrichTweets, includeReplies, include_rts, count } = this
-    let max_id
-
-    if(!includeReplies) {
-      exclude_replies = true
-    } else {
-      exclude_replies = false
-    }
-
-    const tweets = await this.twitter.getUserTimeline({
-      screen_name,
-      enrichTweets, 
-      exclude_replies: !includeReplies,
-      include_rts, 
-      count,
-      since_id,
-    }) 
-
-    // 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 (!max_id || tweet.id_str > max_id) {
-          max_id = tweet.id_str
-        }
-      })
-    }
-    if (max_id) {
-      this.db.set("since_id", max_id)
-    }
-  },
-}