mirror of
https://github.com/CompeyDev/fxtwitter-docker.git
synced 2025-04-05 02:20:54 +01:00
273 lines
9.8 KiB
TypeScript
273 lines
9.8 KiB
TypeScript
import { renderCard } from '../helpers/card';
|
|
import { Constants } from '../constants';
|
|
import { fetchConversation } from '../fetch';
|
|
import { linkFixer } from '../helpers/linkFixer';
|
|
import { handleMosaic } from '../helpers/mosaic';
|
|
import { colorFromPalette } from '../helpers/palette';
|
|
import { translateTweet } from '../helpers/translate';
|
|
import { unescapeText } from '../helpers/utils';
|
|
import { processMedia } from '../helpers/media';
|
|
import { convertToApiUser } from './user';
|
|
import { isGraphQLTweet, isGraphQLTweetNotFoundResponse } from '../utils/graphql';
|
|
|
|
/* This function does the heavy lifting of processing data from Twitter API
|
|
and using it to create FixTweet's streamlined API responses */
|
|
const populateTweetProperties = async (
|
|
tweet: GraphQLTweet,
|
|
conversation: any, // TimelineBlobPartial,
|
|
language: string | undefined
|
|
// eslint-disable-next-line sonarjs/cognitive-complexity
|
|
): Promise<APITweet> => {
|
|
const apiTweet = {} as APITweet;
|
|
|
|
/* With v2 conversation API we re-add the user object ot the tweet because
|
|
Twitter stores it separately in the conversation API. This is to consolidate
|
|
it in case a user appears multiple times in a thread. */
|
|
const graphQLUser = tweet.core.user_results.result;
|
|
const apiUser = convertToApiUser(graphQLUser);
|
|
|
|
/* Populating a lot of the basics */
|
|
apiTweet.url = `${Constants.TWITTER_ROOT}/${apiUser.screen_name}/status/${tweet.rest_id}`;
|
|
apiTweet.id = tweet.rest_id;
|
|
apiTweet.text = unescapeText(linkFixer(tweet, tweet.legacy.full_text || ''));
|
|
apiTweet.author = {
|
|
id: apiUser.id,
|
|
name: apiUser.name,
|
|
screen_name: apiUser.screen_name,
|
|
avatar_url:
|
|
(apiUser.avatar_url || '').replace('_normal', '_200x200') || '',
|
|
avatar_color: '0000FF' /* colorFromPalette(
|
|
tweet.user?.profile_image_extensions_media_color?.palette || []
|
|
),*/,
|
|
banner_url: apiUser.banner_url || ''
|
|
};
|
|
apiTweet.replies = tweet.legacy.reply_count;
|
|
apiTweet.retweets = tweet.legacy.retweet_count;
|
|
apiTweet.likes = tweet.legacy.favorite_count;
|
|
apiTweet.color = apiTweet.author.avatar_color;
|
|
apiTweet.twitter_card = 'tweet';
|
|
apiTweet.created_at = tweet.legacy.created_at;
|
|
apiTweet.created_timestamp = new Date(tweet.legacy.created_at).getTime() / 1000;
|
|
|
|
apiTweet.possibly_sensitive = tweet.legacy.possibly_sensitive;
|
|
|
|
if (tweet.views.state === 'EnabledWithCount') {
|
|
apiTweet.views = parseInt(tweet.views.count || '0') ?? null;
|
|
} else {
|
|
apiTweet.views = null;
|
|
}
|
|
|
|
if (tweet.legacy.lang !== 'unk') {
|
|
apiTweet.lang = tweet.legacy.lang;
|
|
} else {
|
|
apiTweet.lang = null;
|
|
}
|
|
|
|
apiTweet.replying_to = tweet.legacy?.in_reply_to_screen_name || null;
|
|
apiTweet.replying_to_status = tweet.legacy?.in_reply_to_status_id_str || null;
|
|
|
|
const mediaList = Array.from(
|
|
tweet.legacy.extended_entities?.media || tweet.legacy.entities?.media || []
|
|
);
|
|
|
|
// console.log('tweet', JSON.stringify(tweet));
|
|
|
|
/* Populate this Tweet's media */
|
|
mediaList.forEach(media => {
|
|
const mediaObject = processMedia(media);
|
|
if (mediaObject) {
|
|
apiTweet.media = apiTweet.media || {};
|
|
apiTweet.media.all = apiTweet.media?.all || [];
|
|
apiTweet.media.all.push(mediaObject);
|
|
|
|
if (mediaObject.type === 'photo') {
|
|
apiTweet.twitter_card = 'summary_large_image';
|
|
apiTweet.media.photos = apiTweet.media.photos || [];
|
|
apiTweet.media.photos.push(mediaObject);
|
|
} else if (mediaObject.type === 'video' || mediaObject.type === 'gif') {
|
|
apiTweet.twitter_card = 'player';
|
|
apiTweet.media.videos = apiTweet.media.videos || [];
|
|
apiTweet.media.videos.push(mediaObject);
|
|
}
|
|
}
|
|
});
|
|
|
|
/* Grab color palette data */
|
|
/*
|
|
if (mediaList[0]?.ext_media_color?.palette) {
|
|
apiTweet.color = colorFromPalette(mediaList[0].ext_media_color.palette);
|
|
}
|
|
*/
|
|
|
|
/* Handle photos and mosaic if available */
|
|
if ((apiTweet.media?.photos?.length || 0) > 1) {
|
|
const mosaic = await handleMosaic(apiTweet.media?.photos || [], tweet.rest_id);
|
|
if (typeof apiTweet.media !== 'undefined' && mosaic !== null) {
|
|
apiTweet.media.mosaic = mosaic;
|
|
}
|
|
}
|
|
|
|
// Add Tweet source but remove the link HTML tag
|
|
if (tweet.source) {
|
|
apiTweet.source = (tweet.source || '').replace(
|
|
/<a href="(.+?)" rel="nofollow">(.+?)<\/a>/,
|
|
'$2'
|
|
);
|
|
}
|
|
|
|
/* Populate a Twitter card */
|
|
|
|
if (tweet.card) {
|
|
const card = await renderCard(tweet.card);
|
|
if (card.external_media) {
|
|
apiTweet.twitter_card = 'summary_large_image';
|
|
apiTweet.media = apiTweet.media || {};
|
|
apiTweet.media.external = card.external_media;
|
|
}
|
|
if (card.poll) {
|
|
apiTweet.poll = card.poll;
|
|
}
|
|
}
|
|
|
|
/* If a language is specified in API or by user, let's try translating it! */
|
|
if (typeof language === 'string' && language.length === 2 && language !== tweet.legacy.lang) {
|
|
const translateAPI = await translateTweet(
|
|
tweet,
|
|
conversation.guestToken || '',
|
|
language
|
|
);
|
|
if (translateAPI !== null && translateAPI?.translation) {
|
|
apiTweet.translation = {
|
|
text: unescapeText(linkFixer(tweet, translateAPI?.translation || '')),
|
|
source_lang: translateAPI?.sourceLanguage || '',
|
|
target_lang: translateAPI?.destinationLanguage || '',
|
|
source_lang_en: translateAPI?.localizedSourceLanguage || ''
|
|
};
|
|
}
|
|
}
|
|
|
|
return apiTweet;
|
|
};
|
|
|
|
const writeDataPoint = (
|
|
event: FetchEvent,
|
|
language: string | undefined,
|
|
nsfw: boolean,
|
|
returnCode: string,
|
|
flags?: InputFlags
|
|
) => {
|
|
console.log('Writing data point...');
|
|
if (typeof AnalyticsEngine !== 'undefined') {
|
|
const flagString =
|
|
Object.keys(flags || {})
|
|
// @ts-expect-error - TypeScript doesn't like iterating over the keys, but that's OK
|
|
.filter(flag => flags?.[flag])[0] || 'standard';
|
|
|
|
AnalyticsEngine.writeDataPoint({
|
|
blobs: [
|
|
event.request.cf?.colo as string /* Datacenter location */,
|
|
event.request.cf?.country as string /* Country code */,
|
|
event.request.headers.get('user-agent') ??
|
|
'' /* User agent (for aggregating bots calling) */,
|
|
returnCode /* Return code */,
|
|
flagString /* Type of request */,
|
|
language ?? '' /* For translate feature */
|
|
],
|
|
doubles: [nsfw ? 1 : 0 /* NSFW media = 1, No NSFW Media = 0 */],
|
|
indexes: [event.request.headers.get('cf-ray') ?? '' /* CF Ray */]
|
|
});
|
|
}
|
|
};
|
|
|
|
/* API for Twitter statuses (Tweets)
|
|
Used internally by FixTweet's embed service, or
|
|
available for free using api.fxtwitter.com. */
|
|
export const statusAPI = async (
|
|
status: string,
|
|
language: string | undefined,
|
|
event: FetchEvent,
|
|
flags?: InputFlags
|
|
): Promise<TweetAPIResponse> => {
|
|
let wasMediaBlockedNSFW = false;
|
|
let conversation = await fetchConversation(status, event);
|
|
let tweet: GraphQLTweet | TweetTombstone;
|
|
if (isGraphQLTweetNotFoundResponse(conversation)) {
|
|
writeDataPoint(event, language, wasMediaBlockedNSFW, 'NOT_FOUND', flags);
|
|
return { code: 404, message: 'NOT_FOUND' };
|
|
}
|
|
/* Fallback for if Tweet did not load (i.e. NSFW) */
|
|
if (Object.keys(conversation).length === 0) {
|
|
// Try again using elongator API proxy
|
|
console.log('No Tweet was found, loading again from elongator');
|
|
conversation = await fetchConversation(status, event, true);
|
|
if (Object.keys(conversation).length === 0) {
|
|
writeDataPoint(event, language, wasMediaBlockedNSFW, 'NOT_FOUND', flags);
|
|
return { code: 404, message: 'NOT_FOUND' };
|
|
}
|
|
// If the tweet now loads, it was probably NSFW
|
|
wasMediaBlockedNSFW = true;
|
|
}
|
|
// Find this specific tweet in the conversation
|
|
try {
|
|
const instructions = conversation?.data?.threaded_conversation_with_injections_v2?.instructions;
|
|
if (!Array.isArray(instructions)) {
|
|
console.log(JSON.stringify(conversation, null, 2));
|
|
throw new Error('Invalid instructions');
|
|
}
|
|
const timelineAddEntries = instructions.find((e): e is TimeLineAddEntriesInstruction => e?.type === 'TimelineAddEntries');
|
|
if (!timelineAddEntries) throw new Error('No valid timeline entries');
|
|
const graphQLTimelineTweetEntry = timelineAddEntries.entries
|
|
.find((e): e is GraphQLTimelineTweetEntry =>
|
|
// TODO Fix this idk what's up with the typings
|
|
!!(e && typeof e === 'object' && ('entryId' in e) && e?.entryId === `tweet-${status}`));
|
|
if (!graphQLTimelineTweetEntry) throw new Error('No tweet entry with');
|
|
tweet = graphQLTimelineTweetEntry?.content?.itemContent?.tweet_results?.result;
|
|
if (!tweet) throw new Error('No tweet in timeline entry');
|
|
} catch (e) {
|
|
// Api failure at parsing status
|
|
console.log('Tweet could not be accessed, got conversation ', conversation);
|
|
writeDataPoint(event, language, wasMediaBlockedNSFW, 'API_FAIL', flags);
|
|
return { code: 500, message: 'API_FAIL' };
|
|
}
|
|
// If the tweet is not a graphQL tweet it's a tombstone, return the error to the user
|
|
if (!isGraphQLTweet(tweet)) {
|
|
console.log('Tweet was not a valid tweet', tweet);
|
|
writeDataPoint(event, language, wasMediaBlockedNSFW, 'PRIVATE_TWEET', flags);
|
|
return { code: 401, message: 'PRIVATE_TWEET' };
|
|
}
|
|
|
|
/*
|
|
if (tweet.retweeted_status_id_str) {
|
|
tweet = conversation?.globalObjects?.tweets?.[tweet.retweeted_status_id_str] || {};
|
|
}
|
|
*/
|
|
|
|
if (!tweet) {
|
|
return { code: 404, message: 'NOT_FOUND' };
|
|
}
|
|
|
|
/* Creating the response objects */
|
|
const response: TweetAPIResponse = { code: 200, message: 'OK' } as TweetAPIResponse;
|
|
const apiTweet: APITweet = (await populateTweetProperties(
|
|
tweet,
|
|
conversation,
|
|
language
|
|
)) as APITweet;
|
|
|
|
/* We found a quote tweet, let's process that too */
|
|
const quoteTweet = tweet.quoted_status_result;
|
|
if (quoteTweet) {
|
|
apiTweet.quote = (await populateTweetProperties(
|
|
quoteTweet,
|
|
conversation,
|
|
language
|
|
)) as APITweet;
|
|
}
|
|
|
|
/* Finally, staple the Tweet to the response and return it */
|
|
response.tweet = apiTweet;
|
|
|
|
writeDataPoint(event, language, wasMediaBlockedNSFW, 'OK', flags);
|
|
|
|
return response;
|
|
};
|