@sugarcube/plugin-twitter/_dist/plugins/tweet.js

Query the Twitter API as a SugarCube plugin.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

var _fp = require("lodash/fp");

var _dashp = require("dashp");

var _core = require("@sugarcube/core");

var _utils = require("@sugarcube/utils");

var _twitter = require("../twitter");

var _entities = require("../entities");

var _utils2 = require("../utils");

var _assertions = require("../assertions");

const querySource = "twitter_tweet";

const tweetsPlugin = async (envelope, {
  log,
  cfg,
  stats
}) => {
  const decisions = (0, _core.createFeatureDecisions)();

  const tweetIds = _core.envelope.queriesByType(querySource, envelope).map(term => (0, _utils2.parseTweetId)(term));

  const logCounter = (0, _utils.counter)(envelope.data.length, ({
    cnt,
    total,
    percent
  }) => log.debug(`Progress: ${cnt}/${total} units (${percent}%).`), {
    threshold: 50,
    steps: 25
  });
  log.info(`Querying Twitter for ${tweetIds.length} tweets.`);

  const fetchTweets = ids => {
    log.info(`Fetching a chunk of ${ids.length} tweets.`);
    stats.count("total", ids.length);
    return (0, _dashp.flowP)([// Fetch tweets for this chunk.
    (0, _twitter.tweets)(cfg), // Verify each tweet was retrieved and exists.
    ({
      id: response
    }) => {
      const results = [];
      const fails = []; // Verify the response and bail otherwise.

      if (response == null) {
        ids.forEach(id => {
          fails.push({
            type: querySource,
            term: id,
            plugin: "twitter_tweet",
            reason: "No tweets fetched."
          });
        });
        return [results, fails];
      }

      Object.keys(response).forEach(id => {
        logCounter();

        if (response[id] == null) {
          fails.push({
            type: querySource,
            term: id,
            plugin: "twitter_tweet",
            reason: "Tweet does not exist."
          });
        } else {
          stats.count("success");
          results.push(response[id]);
        }
      });
      const op = decisions.canNcube() ? _entities.tweetNcube : _entities.tweetLegacy;
      return [results.map(op), fails];
    }, // Handle any failed tweets.
    ([results, fails]) => {
      if (fails.length > 0) {
        fails.forEach(({
          term,
          reason
        }) => stats.fail({
          type: querySource,
          term,
          reason
        }));
      }

      return results;
    }, // Merge the query into the data unit.
    results => results.map(r => {
      const q = envelope.queries.find(({
        type,
        term
      }) => {
        const tweetId = decisions.canNcube() ? r._sc_id : r.tweet_id;
        return type === querySource && (0, _utils2.parseTweetId)(term) === tweetId;
      });
      if (q == null) return r;
      const {
        tags,
        ...query
      } = q;
      return Object.assign(r, {
        _sc_queries: Array.isArray(r._sc_queries) ? r._sc_queries.concat(query) : [query]
      }, Array.isArray(tags) && tags.length > 0 ? {
        _sc_tags: Array.isArray(r._sc_tags) ? r._sc_tags.concat(tags) : tags
      } : undefined);
    }), // Handle any API errors.
    (0, _dashp.caughtP)(e => {
      const reason = (0, _twitter.parseApiErrors)(e);
      ids.forEach(id => stats.fail({
        type: querySource,
        term: id,
        reason
      }));
      return [];
    })], ids);
  };

  const results = await (0, _dashp.flatmapP)(fetchTweets, (0, _fp.chunk)(50, tweetIds));
  log.info(`Fetched ${results.length} out of ${tweetIds.length} tweets.`);
  return _core.envelope.concatData(results, envelope);
};

const plugin = _core.plugin.liftManyA2([_assertions.assertCredentials, tweetsPlugin]);

plugin.desc = "Fetch individual tweets";
plugin.argv = {};
var _default = plugin;
exports.default = _default;