rettiwt-api 1.0.6 → 1.0.7

package/src/services/data/UserService.ts

@@ -0,0 +1,187 @@
+// SERVICES
+import { FetcherService } from '../FetcherService';
+import { AuthService } from '../AuthService';
+
+// TYPES
+import { User } from '../../types/data/User';
+import { Tweet } from '../../types/data/Tweet';
+import { CursoredData } from '../../types/data/Service';
+import { Result as TweetData } from '../../types/raw/tweet/Tweet';
+import RawUser, { Result as UserData } from '../../types/raw/user/User';
+import RawUserFollowers from '../../types/raw/user/Followers';
+import RawUserFollowing from '../../types/raw/user/Following';
+import RawUserLikes from '../../types/raw/user/Likes';
+import * as Errors from '../../types/data/Errors';
+
+// URLS
+import * as UserUrls from '../helper/urls/Users';
+
+// EXTRACTORS
+import * as UserExtractors from '../helper/extractors/Users';
+
+// DESERIALIZERS
+import * as UserDeserializers from '../helper/deserializers/Users';
+import * as TweetDeserializers from '../helper/deserializers/Tweets';
+
+/**
+ * A service that deals with fetching of data related to user account
+ */
+export class UserService extends FetcherService {
+    // MEMBER METHODS
+    constructor(auth: AuthService) {
+        super(auth);
+    }
+
+    /**
+     * @returns The details of the given user
+     * @param screenName The screen name of the target user.
+     */
+    async getUserDetails(screenName: string): Promise<User> {
+        // Fetching the raw data
+        let res: RawUser = await this.request<RawUser>(UserUrls.userDetailsUrl(screenName), false).then(res => res.data);
+        
+        // Extracting data
+        let data = UserExtractors.extractUserDetails(res);
+
+        // Caching data
+        this.cacheData(data);
+
+        // Parsing data
+        let user = UserDeserializers.toUser(data.required[0]);
+            
+        return user;
+    }
+
+    /**
+     * @returns The details of the user with given rest id
+     * @param restId The screen name of the target user.
+     */
+    async getUserDetailsById(restId: string): Promise<User> {
+        // Getting data from cache
+        let cachedData = await this.readData(restId);
+
+        // If data exists in cache
+        if(cachedData) {
+            return cachedData;
+        }
+        
+        // Fetchin the raw data
+        let res = await this.request<RawUser>(UserUrls.userDetailsByIdUrl(restId), false).then(res => res.data);
+
+        // Extracting data
+        let data = UserExtractors.extractUserDetails(res);
+
+        // Caching data
+        this.cacheData(data);
+
+        // Parsing data
+        let user = UserDeserializers.toUser(data.required[0]);
+            
+        return user;
+    }
+
+    /**
+     * @returns The list of users followed by the target user
+     * @param userId The rest id of the target user
+     * @param count The number of following to fetch, should be >= 40 (when no cursor is provided) and <=100
+     * @param cursor The cursor to next batch. If blank, first batch is fetched
+     */
+    async getUserFollowing(userId: string, count: number, cursor: string): Promise<CursoredData<User>> {
+        // If user is not authenticated, abort
+        if(!this.isAuthenticated) {
+            throw new Error(Errors.AuthenticationErrors.NotAuthenticated);
+        }
+
+        // If invalid count provided
+        if (count < 40 && !cursor) {
+            throw new Error(Errors.ValidationErrors.InvalidCount);
+        }
+
+        // Fetchin the raw data
+        let res = await this.request<RawUserFollowing>(UserUrls.userFollowingUrl(userId, count, cursor)).then(res => res.data);
+        
+        // Extracting data
+        let data = UserExtractors.extractUserFollow(res);
+
+        // Caching data
+        this.cacheData(data);
+
+        // Parsing data
+        let users = data.required.map((item: UserData) => UserDeserializers.toUser(item));
+
+        return {
+            list: users,
+            next: { value: data.cursor }
+        };
+    }
+
+    /**
+     * @returns The list of users following the target user
+     * @param userId The rest id of the target user
+     * @param count The number of followers to fetch, should be >= 40 (when no cursor is provided) and <=100
+     * @param cursor The cursor to next batch. If blank, first batch is fetched
+     */
+    async getUserFollowers(userId: string, count: number, cursor: string): Promise<CursoredData<User>> {
+        // If user is not authenticated, abort
+        if (!this.isAuthenticated) {
+            throw new Error(Errors.AuthenticationErrors.NotAuthenticated);
+        }
+
+        // If invalid count provided
+        if (count < 40 && !cursor) {
+            throw new Error(Errors.ValidationErrors.InvalidCount);
+        }
+
+        // Fetching the raw data
+        let res = await this.request<RawUserFollowers>(UserUrls.userFollowersUrl(userId, count, cursor)).then(res => res.data);
+        
+        // Extracting data
+        let data = UserExtractors.extractUserFollow(res);
+
+        // Caching data
+        this.cacheData(data);
+
+        // Parsing data
+        let users = data.required.map((item: UserData) => UserDeserializers.toUser(item));
+
+        return {
+            list: users,
+            next: { value: data.cursor }
+        };
+    }
+
+    /**
+     * @returns The list of tweets liked by the target user
+     * @param userId The rest id of the target user
+     * @param count The number of likes to fetch, must be >= 40 (when no cursor is provided) and <= 100
+     * @param cursor The cursor to next batch. If blank, first batch is fetched
+     */
+    async getUserLikes(userId: string, count: number, cursor: string): Promise<CursoredData<Tweet>> {
+        // If user is not authenticated, abort
+        if (!this.isAuthenticated) {
+            throw new Error(Errors.AuthenticationErrors.NotAuthenticated);
+        }
+
+        // If invalid count provided
+        if (count < 40 && !cursor) {
+            throw new Error(Errors.ValidationErrors.InvalidCount);
+        }
+
+        // Fetching the raw data
+        let res = await this.request<RawUserLikes>(UserUrls.userLikesUrl(userId, count, cursor)).then(res => res.data);
+        
+        // Extracting data
+        let data = UserExtractors.extractUserLikes(res);
+
+        // Caching data
+        this.cacheData(data);
+
+        // Parsing data
+        let tweets = data.required.map((item: TweetData) => TweetDeserializers.toTweet(item));
+
+        return {
+            list: tweets,
+            next: { value: data.cursor }
+        };
+    }
+};

package/src/services/helper/Parser.ts

@@ -1,4 +1,5 @@
-import { TweetFilter } from '../../types/Tweet';
+// TYPES
+import { TweetFilter } from '../../types/data/Tweet';
 
 /**
  * @returns Whether the given json object is empty or not
@@ -95,14 +96,15 @@ export function toQueryString(filter: TweetFilter): string {
     // Concatenating the input filter arguments to a URL query formatted string
     return [
         filter.words ? filter.words.join(' ') : '',
-        filter.hashtags ? `(${filter.hashtags.map(hashtag => '%23' + hashtag).join(' OR ')})` : '',
+        filter.hashtags ? `(${filter.hashtags.map(hashtag => '#' + hashtag).join(' OR ')})` : '',
         filter.fromUsers ? `(${filter.fromUsers.map(user => `from:${user}`).join(' OR ')})` : '',
         filter.toUsers ? `(${filter.toUsers.map(user => `to:${user}`).join(' OR ')})` : '',
-        filter.mentions ? `(${filter.mentions.map(mention => '%40' + mention).join(' OR ')})` : '',
+        filter.mentions ? `(${filter.mentions.map(mention => '@' + mention).join(' OR ')})` : '',
         filter.startDate ? `since:${filter.startDate}` : '',
         filter.endDate ? `until:${filter.endDate}` : '',
+        filter.sinceId ? `since_id:${filter.sinceId}` : '',
         filter.quoted ? `quoted_tweet_id:${filter.quoted}` : ''
     ]
     .filter(item => item !== '()' && item !== '')
-    .join(' ') + (!filter.links ? '%20-filter%3Alinks' : '');
+    .join(' ') + (!filter.links ? ' -filter:links' : '');
 }

package/src/services/helper/{Deserializers.ts → deserializers/Tweets.ts}

@@ -1,34 +1,9 @@
 // TYPES
-import { User } from '../../types/UserAccount';
-import { Tweet, TweetEntities } from '../../types/Tweet';
-import { Result as RawUser } from '../../types/raw/user/User';
-import { Result as RawTweet, Entities2 as RawTweetEntities } from '../../types/raw/tweet/Tweet';
+import { Tweet, TweetEntities } from '../../../types/data/Tweet';
+import { Result as RawTweet, Entities2 as RawTweetEntities } from '../../../types/raw/tweet/Tweet';
 
 // PARSERS
-import * as Parsers from './Parser';
-
-/**
- * @returns A User object containing the user details
- * @param data The raw user data from Twitter API
- */
-export function toUser(data: RawUser): User {
-    return {
-        id: data.rest_id,
-        userName: data.legacy.screen_name,
-        fullName: data.legacy.name,
-        createdAt: data.legacy.created_at,
-        description: data.legacy.description,
-        isVerified: data.legacy.verified,
-        favouritesCount: data.legacy.favourites_count,
-        followersCount: data.legacy.followers_count,
-        followingsCount: data.legacy.friends_count,
-        statusesCount: data.legacy.statuses_count,
-        location: data.legacy.location,
-        pinnedTweet: data.legacy.pinned_tweet_ids_str[0],
-        profileBanner: data.legacy.profile_banner_url,
-        profileImage: data.legacy.profile_image_url_https
-    };
-}
+import * as Parsers from '../Parser';
 
 /**
  * @returns A TweetEntities object containing the various tweet entities

package/src/services/helper/deserializers/Users.ts

@@ -0,0 +1,26 @@
+// TYPES
+import { User } from '../../../types/data/User';
+import { Result as RawUser } from '../../../types/raw/user/User';
+
+/**
+ * @returns A User object containing the user details
+ * @param data The raw user data from Twitter API
+ */
+export function toUser(data: RawUser): User {
+    return {
+        id: data.rest_id,
+        userName: data.legacy.screen_name,
+        fullName: data.legacy.name,
+        createdAt: data.legacy.created_at,
+        description: data.legacy.description,
+        isVerified: data.legacy.verified,
+        favouritesCount: data.legacy.favourites_count,
+        followersCount: data.legacy.followers_count,
+        followingsCount: data.legacy.friends_count,
+        statusesCount: data.legacy.statuses_count,
+        location: data.legacy.location,
+        pinnedTweet: data.legacy.pinned_tweet_ids_str[0],
+        profileBanner: data.legacy.profile_banner_url,
+        profileImage: data.legacy.profile_image_url_https
+    };
+}

package/src/services/helper/extractors/Tweets.ts

@@ -0,0 +1,252 @@
+// TYPES
+import { DataExtract } from '../../../types/Resolvers';
+import { DataErrors } from '../../../types/data/Errors';
+import RawTweet from '../../../types/raw/tweet/Tweet';
+import RawTweets from '../../../types/raw/tweet/Tweets';
+import RawRetweeters from '../../../types/raw/tweet/Retweeters';
+import RawLikers from '../../../types/raw/tweet/Favouriters';
+
+// PARSERS
+import * as Parsers from '../Parser';
+
+/**
+ * @returns The raw tweets data formatted and sorted into required and additional data
+ * @param res The raw response received from TwitterAPI
+ */
+export function extractTweets(res: RawTweets): DataExtract {
+    let required: any[] = [];                                               // To store the reqruied raw data
+    let cursor: string = '';                                                // To store the cursor to next batch
+    let users: any[] = [];                                                  // To store additional user data
+    let tweets: any[] = [];                                                 // To store additional tweet data
+
+    // Getting raw tweet list
+    let dataTweets = res.globalObjects.tweets;
+
+    // Getting raw users list
+    let dataUsers = res.globalObjects.users;
+
+    // If tweets found
+    if (!Parsers.isJSONEmpty(dataTweets)) {
+        // Destructuring the list of tweets
+        for (let key of Object.keys(dataTweets)) {
+            required.push({ rest_id: dataTweets[key].id_str, legacy: dataTweets[key] });
+            tweets.push({ rest_id: dataTweets[key].id_str, legacy: dataTweets[key] });
+        }
+
+        // Destructuring the list of users
+        for (let key of Object.keys(dataUsers)) {
+            users.push({ rest_id: dataUsers[key].id_str, legacy: dataUsers[key] });
+        }
+
+        // Getting the cursor to next batch
+        // If not first batch
+        if (res.timeline.instructions.length > 2) {
+            cursor = res.timeline.instructions[2]?.replaceEntry.entry.content.operation?.cursor.value ?? '';
+        }
+        // If first batch
+        else {
+            cursor = res.timeline.instructions[0].addEntries?.entries.filter(item => item.entryId.indexOf('cursor-bottom') != -1)[0].content.operation?.cursor.value ?? '';
+        }
+    }
+
+    // Returning the data
+    return {
+        required: required,
+        cursor: cursor,
+        users: users,
+        tweets: tweets
+    };
+}
+
+/**
+ * @returns The raw tweet data formatted and sorted into required and additional data
+ * @param res The raw response received from TwitterAPI
+ * @param tweetId The rest id of the tweet to fetch
+ */
+export function extractTweet(res: RawTweet, tweetId: string): DataExtract {
+    let required: any[] = [];                                               // To store the reqruied raw data
+    let cursor: string = '';                                                // To store the cursor to next batch
+    let users: any[] = [];                                                  // To store additional user data
+    let tweets: any[] = [];                                                 // To store additional tweet data
+
+    // If tweet does not exist
+    if (Parsers.isJSONEmpty(res.data)) {
+        throw new Error(DataErrors.TweetNotFound);
+    }
+
+    // Destructuring the received raw data
+    res.data.threaded_conversation_with_injections_v2.instructions.filter(item => item['type'] === 'TimelineAddEntries')[0].entries?.forEach(entry => {
+        // If entry is of type tweet and tweet exists
+        if (entry.entryId.indexOf('tweet') != -1 && entry.content.itemContent?.tweet_results?.result.__typename === 'Tweet') {
+            // If this is the required tweet
+            if (entry.entryId.indexOf(tweetId) != -1) {
+                required.push(entry.content.itemContent.tweet_results.result);
+            }
+            tweets.push(entry.content.itemContent.tweet_results.result);
+            users.push(entry.content.itemContent.tweet_results.result.core.user_results.result);
+        }
+        // If entry if of type conversation
+        else if (entry.entryId.indexOf('conversationthread') != -1) {
+            // Iterating over the conversation
+            entry.content.items?.forEach(item => {
+                // If item is of type tweet and tweet exists
+                if (item.entryId.indexOf('tweet') != -1 && item.item.itemContent.tweet_results?.result.__typename === 'Tweet') {
+                    required.push(item.item.itemContent.tweet_results.result);
+                    tweets.push(item.item.itemContent.tweet_results.result);
+                    users.push(item.item.itemContent.tweet_results.result.core.user_results.result);
+                }
+            });
+        }
+    });
+
+    // Returning the data
+    return {
+        required: required,
+        cursor: cursor,
+        users: users,
+        tweets: tweets
+    };
+}
+
+/**
+ * @returns The raw tweet likers data formatted and sorted into required and additional data
+ * @param res The raw response received from TwitterAPI
+ */
+export function extractTweetLikers(res: RawLikers): DataExtract {
+    let required: any[] = [];                                               // To store the reqruied raw data
+    let cursor: string = '';                                                // To store the cursor to next batch
+    let users: any[] = [];                                                  // To store additional user data
+    let tweets: any[] = [];                                                 // To store additional tweet data
+
+    // If tweet does not exist
+    if (Parsers.isJSONEmpty(res.data.favoriters_timeline)) {
+        throw new Error(DataErrors.TweetNotFound);
+    }
+
+    // If likes found
+    if (res.data.favoriters_timeline.timeline.instructions.length) {
+        // Destructuring raw list of likers
+        res.data.favoriters_timeline.timeline.instructions.filter(item => item.type === 'TimelineAddEntries')[0].entries.forEach(entry => {
+            // If entry is of type user and user exists
+            if (entry.entryId.indexOf('user') != -1 && entry.content.itemContent?.user_results.result.__typename === 'User') {
+                required.push(entry.content.itemContent.user_results.result);
+                users.push(entry.content.itemContent.user_results.result);
+            }
+            // If entry is of type cursor
+            else if (entry.entryId.indexOf('cursor-bottom') != -1) {
+                cursor = entry.content.value ?? '';
+            }
+        });
+    }
+
+    // Returning the data
+    return {
+        required: required,
+        cursor: cursor,
+        users: users,
+        tweets: tweets
+    };
+}
+
+/**
+ * @returns The raw tweet retweeters data formatted and sorted into required and additional data
+ * @param res The raw response received from TwitterAPI
+ */
+export function extractTweetRetweeters(res: RawRetweeters): DataExtract {
+    let required: any[] = [];                                               // To store the reqruied raw data
+    let cursor: string = '';                                                // To store the cursor to next batch
+    let users: any[] = [];                                                  // To store additional user data
+    let tweets: any[] = [];                                                 // To store additional tweet data
+
+    // If tweet does not exist
+    if (Parsers.isJSONEmpty(res.data.retweeters_timeline)) {
+        throw new Error(DataErrors.TweetNotFound);
+    }
+
+    // If retweeters found
+    if (res.data.retweeters_timeline.timeline.instructions.length) {
+        // Destructuring raw list of retweeters
+        res.data.retweeters_timeline.timeline.instructions.filter(item => item.type === 'TimelineAddEntries')[0].entries.forEach(entry => {
+            // If entry is of type user and user exists
+            if (entry.entryId.indexOf('user') != -1 && entry.content.itemContent?.user_results.result.__typename === 'User') {
+                required.push(entry.content.itemContent.user_results.result);
+                users.push(entry.content.itemContent.user_results.result);
+            }
+            // If entry is of type cursor
+            else if (entry.entryId.indexOf('cursor-bottom') != -1) {
+                cursor = entry.content.value ?? '';
+            }
+        });
+    }
+
+    // Returning the data
+    return {
+        required: required,
+        cursor: cursor,
+        users: users,
+        tweets: tweets
+    };
+}
+
+/**
+ * @returns The raw tweet replies data formatted and sorted into required and additional data
+ * @param res The raw response received from TwitterAPI
+ * @param tweetId The id of the tweet whose replies must be extracted
+ */
+export function extractTweetReplies(res: RawTweet, tweetId: string): DataExtract {
+    let required: any[] = [];                                               // To store the reqruied raw data
+    let cursor: string = '';                                                // To store the cursor to next batch
+    let users: any[] = [];                                                  // To store additional user data
+    let tweets: any[] = [];                                                 // To store additional tweet data
+
+    // If tweet does not exist
+    if (Parsers.isJSONEmpty(res.data)) {
+        throw new Error(DataErrors.TweetNotFound);
+    }
+
+    // Destructuring the received raw data
+    res.data.threaded_conversation_with_injections_v2.instructions.filter(item => item.type === 'TimelineAddEntries')[0].entries?.map(entry => {
+        // If entry is of type tweet
+        if (entry.entryId.indexOf('tweet') != -1) {
+            // If tweet exists
+            if (entry.content.itemContent?.tweet_results?.result.__typename === 'Tweet') {
+                tweets.push(entry.content.itemContent.tweet_results.result);
+                users.push(entry.content.itemContent.tweet_results.result.core.user_results.result);
+            }
+        }
+        // If entry if of type conversation/reply
+        else if (entry.entryId.indexOf('conversationthread') != -1) {
+            // If tweet exists
+            if (entry.content.items?.at(0)?.item.itemContent.tweet_results?.result.__typename === 'Tweet') {
+                // Adding the 1st entry, which is a reply, to required list
+                required.push(entry.content.items[0].item.itemContent.tweet_results?.result);
+                tweets.push(entry.content.items[0].item.itemContent.tweet_results?.result);
+                users.push(entry.content.items[0].item.itemContent.tweet_results?.result.core.user_results.result);
+            }
+
+            // Iterating over the rest of the conversation
+            entry.content.items?.forEach(item => {
+                // If item is of type tweet
+                if (item.entryId.indexOf('tweet') != -1) {
+                    // If tweet exists
+                    if (item.item.itemContent.tweet_results?.result.__typename === 'Tweet') {
+                        tweets.push(item.item.itemContent.tweet_results.result);
+                        users.push(item.item.itemContent.tweet_results.result.core.user_results.result);
+                    }
+                }
+            });
+        }
+        // If entry is of type bottom cursor
+        else if (entry.entryId.indexOf('cursor-bottom') != -1) {
+            cursor = entry.content.itemContent?.value ?? '';
+        }
+    });
+
+    // Returning the data
+    return {
+        required: required,
+        cursor: cursor,
+        users: users,
+        tweets: tweets
+    };
+}

package/src/services/helper/extractors/Users.ts

@@ -0,0 +1,137 @@
+// TYPES
+import { DataExtract } from '../../../types/Resolvers'
+import { DataErrors } from '../../../types/data/Errors';
+import RawUser from '../../../types/raw/user/User';
+import RawUserFollowers from '../../../types/raw/user/Followers';
+import RawUserFollowing from '../../../types/raw/user/Following';
+import RawUserLikes from '../../../types/raw/user/Likes';
+
+// PARSERS
+import * as Parsers from '../Parser';
+
+/**
+ * @returns The raw user account data formatted and sorted into required and additional data
+ * @param res The raw response received from Twitter
+ */
+export function extractUserDetails(res: RawUser): DataExtract {
+    let required: any[] = [];                                               // To store the reqruied raw data
+    let cursor: string = '';                                                // To store the cursor to next batch
+    let users: any[] = [];                                                  // To store additional user data
+    let tweets: any[] = [];                                                 // To store additional tweet data
+
+    // If user not found or account suspended
+    if (res.data?.user?.result?.__typename !== 'User') {
+        throw new Error(DataErrors.UserNotFound);
+    }
+
+    // Destructuring user account data
+    required.push(res.data.user.result);
+    users.push(res.data.user.result);
+
+    // Returning the data
+    return {
+        required: required,
+        cursor: cursor,
+        users: users,
+        tweets: tweets
+    };
+}
+
+/**
+ * @returns The raw user following/followers data formatted and sorted into required and additional data
+ * @param res The raw response received from TwitterAPI
+ */
+export function extractUserFollow(res: RawUserFollowers | RawUserFollowing): DataExtract {
+    let required: any[] = [];                                               // To store the reqruied raw data
+    let cursor: string = '';                                                // To store the cursor to next batch
+    let users: any[] = [];                                                  // To store additional user data
+    let tweets: any[] = [];                                                 // To store additional tweet data
+
+    // If user does not exist
+    if (Parsers.isJSONEmpty(res.data.user)) {
+        throw new Error(DataErrors.UserNotFound);
+    }
+
+    // Extracting the raw list
+    res.data.user.result.timeline.timeline.instructions.forEach(item => {
+        if (item.type === 'TimelineAddEntries') {
+            // If no follow found
+            if (item.entries?.length == 2) {
+                // Returning the data
+                return {
+                    required: required,
+                    cursor: cursor,
+                    users: users,
+                    tweets: tweets
+                };
+            }
+
+            // Destructuring data
+            item.entries?.forEach(entry => {
+                // If entry is of type user and user account exists
+                if (entry.entryId.indexOf('user') != -1 && entry.content.itemContent?.user_results.result.__typename === 'User') {
+                    required.push(entry.content.itemContent.user_results.result);
+                    users.push(entry.content.itemContent.user_results.result);
+                }
+                // If entry is of type cursor
+                else if (entry.entryId.indexOf('cursor-bottom') != -1) {
+                    cursor = entry.content.value ?? '';
+                }
+            });
+        }
+    });
+
+    // Returning the data
+    return {
+        required: required,
+        cursor: cursor,
+        users: users,
+        tweets: tweets
+    };
+}
+
+/**
+ * @returns The raw user likes data formatted and sorted into required and additional data
+ * @param res The raw response received from TwitterAPI
+ */
+export function extractUserLikes(res: RawUserLikes): DataExtract {
+    let required: any[] = [];                                               // To store the reqruied raw data
+    let cursor: string = '';                                                // To store the cursor to next batch
+    let users: any[] = [];                                                  // To store additional user data
+    let tweets: any[] = [];                                                 // To store additional tweet data
+
+    // If user does not exist
+    if (Parsers.isJSONEmpty(res.data.user)) {
+        throw new Error(DataErrors.UserNotFound);
+    }
+
+    // If user likes found
+    if (res.data.user.result.timeline_v2.timeline.instructions.length) {
+        // Extracting the raw list
+        res.data.user.result.timeline_v2.timeline.instructions.forEach(item => {
+            if (item.type === 'TimelineAddEntries') {
+                // Destructuring data
+                item.entries.forEach(entry => {
+                    // If entry is of type tweet and tweet exists
+                    if (entry.entryId.indexOf('tweet') != -1 && entry.content.itemContent?.tweet_results.result.__typename === 'Tweet') {
+                        required.push(entry.content.itemContent.tweet_results.result);
+                        users.push(entry.content.itemContent.tweet_results.result.core.user_results.result);
+                        tweets.push(entry.content.itemContent.tweet_results.result);
+                    }
+                    // If entry is of type cursor
+                    else if (entry.entryId.indexOf('cursor-bottom') != -1) {
+                        cursor = entry.content.value ?? '';
+                    }
+                });
+            }
+        });
+    }
+
+    // Returning the data
+    return {
+        required: required,
+        cursor: cursor,
+        users: users,
+        tweets: tweets
+    };
+}

package/src/services/helper/urls/Authentication.ts

@@ -0,0 +1,6 @@
+/**
+ * @returns The url for fetching a guest token
+ */
+export function guestTokenUrl(): string {
+    return `https://api.twitter.com/1.1/guest/activate.json`;
+}