rettiwt-api 1.4.0 → 2.0.0

package/src/services/data/UserService.ts

@@ -1,221 +0,0 @@
-// PACKAGES
-import {
-    Url,
-    EResourceType,
-    IUserDetailsResponse,
-    IUserFollowersResponse,
-    IUserFollowingResponse,
-    IUserLikesResponse,
-    ITweet as IRawTweet,
-    IUser as IRawUser
-} from 'rettiwt-core';
-
-// SERVICES
-import { FetcherService } from '../util/FetcherService';
-import { AuthService } from '../auth/AuthService';
-
-// MODELS
-import { User } from '../../models/data/User';
-import { UserListArgs } from '../../models/args/UserListArgs';
-import { Tweet } from '../../models/data/Tweet';
-
-// TYPES
-import { CursoredData } from '../../models/data/CursoredData';
-
-// ENUMS
-import { AuthenticationErrors } from '../../enums/Errors';
-
-// EXTRACTORS
-import * as UserExtractors from '../helper/extractors/Users';
-import { TweetService } from './TweetService';
-
-/**
- * Handles fetching of data related to user account
- */
-export class UserService extends FetcherService {
-    /**
-     * @param auth The AuthService instance to use for authentication.
-     */
-    constructor(auth: AuthService) {
-        super(auth);
-    }
-
-    /**
-     * @param id The id/username of the target user.
-     * 
-     * @returns The details of the given user.
-     * 
-     * @throws {@link Errors.AuthenticationErrors.NotAuthenticated} error, if no cookies have been provided.
-     * @throws {@link Errors.DataErrors.UserNotFound} error, if no user with the given username was found.
-     */
-    async getUserDetails(id: string): Promise<User> {
-        // If user is not authenticated, abort
-        if (!this.isAuthenticated) {
-            throw new Error(AuthenticationErrors.NotAuthenticated);
-        }
-
-        let res: IUserDetailsResponse;
-
-        // Getting data from cache
-        let cachedData = await this.readData(id);
-
-        // If data exists in cache
-        if (cachedData) {
-            return cachedData;
-        }
-        // Else, fetch the data from Twitter instead
-        else {
-            // Preparing the URL
-            const url: string = new Url(EResourceType.USER_DETAILS, { id: id }).toString();
-
-            // Fetching the raw data
-            res = await this.request<IUserDetailsResponse>(url).then(res => res.data);
-
-            // Extracting data
-            let data = UserExtractors.extractUserDetails(res);
-
-            // Caching data
-            this.cacheData(data);
-
-            // Parsing data
-            let user = new User(data.required[0]);
-
-            return user;
-        }
-    }
-
-    /**
-     * @param userId The rest id of the target user.
-     * @param count The number of tweets 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.
-     * 
-     * @returns The list of tweets nade by the target user.
-     * 
-     * @throws {@link Errors.AuthenticationErrors.NotAuthenticated} error, if no cookies have been provided.
-     * @throws {@link Errors.ValidationErrors.InvalidCount} error, if invalid count has been provided.
-     * @throws {@link Errors.DataErrors.UserNotFound} error, if invalid count has been provided.
-     * 
-     * @deprecated Use [this](https://rishikant181.github.io/Rettiwt-API/classes/TweetService.html#getTweets) method instead. It's better in every possible way!
-     */
-    async getUserTweets(userId: string, count?: number, cursor?: string): Promise<CursoredData<Tweet>> {
-        // Getting the username of the target user
-        const userName: string = (await this.getUserDetails(userId)).userName;
-
-        // Getting the tweets of the target user
-        return new TweetService(this.auth).getTweets({
-            fromUsers: [userName]
-        }, count, cursor);
-    }
-
-    /**
-     * @param userId The rest id of the target user.
-     * @param count The number of following 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.
-     * 
-     * @returns The list of users followed by the target user.
-     * 
-     * @throws {@link Errors.AuthenticationErrors.NotAuthenticated} error, if no cookies have been provided.
-     * @throws {@link Errors.ValidationErrors.InvalidCount} error, if invalid count has been provided.
-     * @throws {@link Errors.DataErrors.UserNotFound} error, if invalid count has been provided.
-     */
-    async getUserFollowing(userId: string, count?: number, cursor?: string): Promise<CursoredData<User>> {
-        // If user is not authenticated, abort
-        if (!this.isAuthenticated) {
-            throw new Error(AuthenticationErrors.NotAuthenticated);
-        }
-
-        // Objectifying parameters
-        let args: UserListArgs = new UserListArgs(count, cursor);
-
-        // Preparing the URL
-        const url: string = new Url(EResourceType.USER_FOLLOWING, { id: userId, count: args.count, cursor: args.cursor }).toString();
-
-        // Fetchin the raw data
-        let res = await this.request<IUserFollowingResponse>(url).then(res => res.data);
-
-        // Extracting data
-        let data = UserExtractors.extractUserFollow(res);
-
-        // Caching data
-        this.cacheData(data);
-
-        // Parsing data
-        let users = data.required.map((item: IRawUser) => new User(item));
-
-        return new CursoredData<User>(users, data.cursor);
-    }
-
-    /**
-     * @param userId The rest id of the target user.
-     * @param count The number of followers 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.
-     * 
-     * @returns The list of users following the target user.
-     * 
-     * @throws {@link Errors.AuthenticationErrors.NotAuthenticated} error, if no cookies have been provided.
-     * @throws {@link Errors.ValidationErrors.InvalidCount} error, if invalid count has been provided.
-     * @throws {@link Errors.DataErrors.UserNotFound} error, if invalid count has been provided.
-     */
-    async getUserFollowers(userId: string, count?: number, cursor?: string): Promise<CursoredData<User>> {
-        // If user is not authenticated, abort
-        if (!this.isAuthenticated) {
-            throw new Error(AuthenticationErrors.NotAuthenticated);
-        }
-
-        // Objectifying parameters
-        let args: UserListArgs = new UserListArgs(count, cursor);
-
-        // Preparing the URL
-        const url: string = new Url(EResourceType.USER_FOLLOWERS, { id: userId, count: args.count, cursor: args.cursor }).toString();
-
-        // Fetching the raw data
-        let res = await this.request<IUserFollowersResponse>(url).then(res => res.data);
-
-        // Extracting data
-        let data = UserExtractors.extractUserFollow(res);
-
-        // Caching data
-        this.cacheData(data);
-
-        // Parsing data
-        let users = data.required.map((item: IRawUser) => new User(item));
-
-        return new CursoredData<User>(users, data.cursor);
-    }
-
-    /**
-     * @param userId The rest id of the target user.
-     * @param count The number of likes to fetch.
-     * @param cursor The cursor to next batch. If blank, first batch is fetched, must be >= 40 (when no cursor is provided) and <=100.
-     * 
-     * @returns The list of tweets liked by the target user.
-     * 
-     * @throws {@link AuthenticationErrors.NotAuthenticated} error, if no cookies have been provided.
-     */
-    async getUserLikes(userId: string, count?: number, cursor?: string): Promise<CursoredData<Tweet>> {
-        // If user is not authenticated, abort
-        if (!this.isAuthenticated) {
-            throw new Error(AuthenticationErrors.NotAuthenticated);
-        }
-
-        // Objectifying parameters
-        let args: UserListArgs = new UserListArgs(count, cursor);
-
-        // Preparing the URL
-        const url: string = new Url(EResourceType.USER_LIKES, { id: userId, count: args.count, cursor: args.cursor }).toString();
-
-        // Fetching the raw data
-        let res = await this.request<IUserLikesResponse>(url).then(res => res.data);
-
-        // Extracting data
-        let data = UserExtractors.extractUserLikes(res);
-
-        // Caching data
-        this.cacheData(data);
-
-        // Parsing data
-        let tweets = data.required.map((item: IRawTweet) => new Tweet(item));
-
-        return new CursoredData<Tweet>(tweets, data.cursor);
-    }
-};

package/src/services/helper/Headers.ts

@@ -1,60 +0,0 @@
-// TYPES
-import { IGuestCredentials, IAuthCredentials } from '../../types/Authentication';
-
-/**
- * @param authToken The authentication token received from Twitter
- * @param csrfToken The csrf token received from Twitter
- * @param cookie The cookie associated with the logged in account
- * @returns The header required for making authorized HTTP requests
- */
-export function authorizedHeader(authCred: IAuthCredentials): any {
-    return {
-        'sec-ch-ua': '"Not_A Brand";v="99", "Microsoft Edge";v="109", "Chromium";v="109"',
-        'x-twitter-client-language': 'en',
-        'x-csrf-token': authCred.csrfToken,
-        'sec-ch-ua-mobile': '?0',
-        'authorization': authCred.authToken,
-        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36 Edg/109.0.1518.61',
-        'x-twitter-auth-type': 'OAuth2Session',
-        'x-twitter-active-user': 'yes',
-        'sec-ch-ua-platform': '"Windows"',
-        'Accept': '*/*',
-        'host': 'twitter.com',
-        'Cookie': authCred.cookie
-    };
-}
-
-/**
- * @param guestCred The guest credentials to use
- * @returns The header requred for making guest HTTP requests
- */
-export function guestHeader(guestCred: IGuestCredentials): any {
-    return {
-        'Accept': '*/*',
-        'authorization': guestCred.authToken,
-        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36 Edg/109.0.1518.70',
-        'x-guest-token': guestCred.guestToken
-    };
-}
-
-/**
- * @param guestCred The guest credentials to use for making the login requests
- * @param cookie The cookie to be used
- * @returns The header for making HTTP request for logging in
- */
-export function loginHeader(guestCred: IGuestCredentials, cookie: string): any {
-    return [
-        `sec-ch-ua: "Not_A Brand";v="99", "Microsoft Edge";v="109", "Chromium";v="109"`,
-        `x-twitter-client-language: en`,
-        `sec-ch-ua-mobile: ?0`,
-        `authorization: ${guestCred.authToken}`,
-        `User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36 Edg/109.0.1518.78`,
-        `content-type: application/json`,
-        `x-guest-token: ${guestCred.guestToken}`,
-        `x-twitter-active-user: yes`,
-        `sec-ch-ua-platform: "Windows"`,
-        `Accept: */*`,
-        `host: api.twitter.com`,
-        `Cookie: ${cookie}`
-    ];
-}

package/src/services/helper/Parser.ts

@@ -1,89 +0,0 @@
-// PACKAGE
-import { ITweetFilter } from 'rettiwt-core';
-
-/**
- * @returns Whether the given json object is empty or not
- * @param data The input JSON object which needs to be checked
- */
-export function isJSONEmpty(data: any): boolean {
-    // If the JSON has any keys, it's not empty
-    if (Object.keys(data).length == 0) {
-        return true;
-    }
-    // Else, it's empty
-    else {
-        return false;
-    }
-}
-
-/**
- * @returns The value associated with the given key inside the given json
- * @param data The json data within which to search for the value
- * @param key The key to search for
- * @param last Whether to begin searching from the end
- */
-export function findJSONKey(data: any, key: string, last: boolean = false): any {
-    let jsonStr: string = JSON.stringify(data);                                 // To store the input data as string
-    let extStr: string = '';                                                    // To store the extracted string
-    let len: number = jsonStr.length;                                           // To store length of input data
-
-    /**
-     * Getting the position to start extracting data from
-     * This the position just after the key plus ":"
-     * */
-    let start: number = !last ? (jsonStr.indexOf(`"${key}"`) + `"${key}":`.length) : (jsonStr.lastIndexOf(`"${key}"`) + `"${key}":`.length);
-
-    for (let i = start; i < len; i++) {
-        // Getting each character
-        let char: string = jsonStr[i];
-
-        // If not ending of value
-        if (char != ',' && char != '\n') {
-            extStr += char;
-        }
-        // If ending of value
-        else {
-            break;
-        }
-    }
-
-    // Removing begginning and ending quotes from string
-    /**
-     * I don't know how this regex I used works. I just copied it from StackOverflow
-     * Here is the link to the thread: https://stackoverflow.com/q/19156148
-     */
-    extStr = extStr.replace(/^"|"$/g, '');
-
-    return extStr;
-}
-
-/**
- * @returns A list of data from a singleton data
- * @param data The data to be converted to a list
- */
-export function dataToList(data: any | any[]): any[] {
-    // If data is already a list
-    if (Array.isArray(data)) {
-        return data;
-    }
-    // If data is not array
-    else {
-        return [data];
-    }
-}
-
-/**
- * @param text The text to be normalized
- * @returns The text after being formatted to remove unnecessary characters
- */
-export function normalizeText(text: string): string {
-    let normalizedText: string = '';                                                // To store the normalized text
-
-    // Removing unnecessary full stops, and other characters
-    normalizedText = text.replace(/\n/g, '.').replace(/[.]+[\s+.\s+]+/g, '. ');
-
-    // Adding full-stop to the end if does not exist already
-    normalizedText = normalizedText.endsWith('.') ? normalizedText : (normalizedText + '.');
-
-    return normalizedText;
-}

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

@@ -1,190 +0,0 @@
-// PACKAGE
-import {
-    ITweetSearchResponse,
-    ITweetDetailsResponse,
-    ITweetFavoritersResponse,
-    ITweetRetweetersResponse,
-} from 'rettiwt-core';
-
-
-// TYPES
-import { IDataExtract } from '../../../types/Resolvers';
-import { DataErrors } from '../../../enums/Errors';
-
-// 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: ITweetSearchResponse): IDataExtract {
-    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.search_by_raw_query)) {
-        throw new Error(DataErrors.NoMatchingTweetsFound);
-    }
-
-    // If tweets
-    if (res.data.search_by_raw_query.search_timeline.timeline.instructions.length) {
-        // Destructuring raw list of tweets
-        res.data.search_by_raw_query.search_timeline.timeline.instructions.filter(item => item.type === 'TimelineAddEntries')[0].entries?.forEach(entry => {
-            // If entry is of type tweet and tweet exists
-            if (entry.entryId.includes('tweet') && 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 and cursor exists
-            else if (entry.entryId.includes('cursor-bottom')) {
-                cursor = entry.content.value ?? '';
-            }
-        });
-        // If cursor not found in 'TimelineAddEntries', getting cursor from 'TimlineReplaceEntry'
-        if (!cursor) {
-            cursor = res.data.search_by_raw_query.search_timeline.timeline.instructions.filter(item => item.entry_id_to_replace?.includes('cursor-bottom'))[0].entry?.content.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: ITweetDetailsResponse, tweetId: string): IDataExtract {
-    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: ITweetFavoritersResponse): IDataExtract {
-    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: ITweetRetweetersResponse): IDataExtract {
-    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
-    };
-}