rettiwt-api 1.4.0 → 2.0.1

package/src/services/auth/AccountService.ts

@@ -1,283 +0,0 @@
-// PACKAGES
-import { curly, CurlyResult } from 'node-libcurl';
-
-// SERVICES
-import { AuthService } from './AuthService';
-
-// TYPES
-import { IGuestCredentials, IAuthCookie } from '../../types/Authentication';
-
-// ENUMS
-import { HttpStatus } from '../../enums/HTTP';
-import { AuthenticationErrors } from '../../enums/Errors';
-
-// HELPERS
-import LoginFlows from '../helper/payloads/LoginFlows';
-import { loginHeader } from '../helper/Headers';
-import { Cookie, CookieJar } from 'cookiejar';
-
-/**
- * Handles all operations related to a user's account, such as loggin in, managing account, etc
- * @public
- */
-export class AccountService {
-    /** The AuthService instance to use for authentication. */
-    private auth: AuthService = new AuthService();
-
-    /** The current guest credentials to use. */
-    private guestCreds: IGuestCredentials = { authToken: '', guestToken: '' };
-
-    /** The email id of Twitter account to be logged into. */
-    private email: string = '';
-
-    /** The user name of the Twitter account ot be logged into */
-    private userName: string = '';
-
-    /** The password to the Twitter account to be logged into. */
-    private password: string = '';
-
-    /** The cookies received from Twitter after logging in. */
-    private cookies: Cookie[] = [];
-
-    /** The flow token received after execution of current flow. */
-    private flowToken: string = '';
-
-    /**
-     * @returns The current guest credentials to use. If if does not exists, then a new one is created
-     */
-    private async getGuestCredentials(): Promise<IGuestCredentials> {
-        // If a guest credential has not been already set, get a new one
-        if (!this.guestCreds.guestToken) {
-            this.guestCreds = await this.auth.getGuestCredentials();
-        }
-
-        return this.guestCreds;
-    }
-
-    /**
-     * Step 1: Initiates login
-     * @internal
-     */
-    private async initiateLogin(): Promise<void> {
-        // Initiating the login process
-        const res: CurlyResult = await curly.post(LoginFlows.InitiateLogin.url, {
-            httpHeader: loginHeader(await this.getGuestCredentials(), this.cookies.toString()),
-            sslVerifyPeer: false,
-            postFields: ''
-        });
-
-        // Storing cookies received
-        this.cookies = new CookieJar().setCookies(res.headers[0]['Set-Cookie'] as string[]);
-
-        // Getting the flow token
-        this.flowToken = res.data['flow_token'];
-
-        // Executing next subtask
-        await this.jsInstrumentationSubtask();
-    }
-
-    /**
-     * Step 2: Does something
-     * @internal
-     */
-    private async jsInstrumentationSubtask(): Promise<void> {
-        // Executing the subtask
-        const res: CurlyResult = await curly.post(LoginFlows.JsInstrumentationSubtask.url, {
-            httpHeader: loginHeader(await this.getGuestCredentials(), this.cookies.join(';').toString()),
-            sslVerifyPeer: false,
-            postFields: JSON.stringify(LoginFlows.JsInstrumentationSubtask.body(this.flowToken))
-        });
-
-        // Getting the flow token
-        this.flowToken = res.data['flow_token'];
-
-        // Executing next subtask
-        await this.enterUserIdentifier();
-    }
-
-    /**
-     * Step 3: Takes the email for login
-     * @internal
-     * 
-     * @throws {@link AuthenticationErrors.InvalidEmail}, if email does not exist.
-     */
-    private async enterUserIdentifier(): Promise<void> {
-        // Executing the subtask
-        const res: CurlyResult = await curly.post(LoginFlows.EnterUserIdentifier.url, {
-            httpHeader: loginHeader(await this.getGuestCredentials(), this.cookies.join(';').toString()),
-            sslVerifyPeer: false,
-            postFields: JSON.stringify(LoginFlows.EnterUserIdentifier.body(this.flowToken, this.email))
-        });
-
-        // If no account found with given email
-        if (res.statusCode == HttpStatus.BadRequest && res.data.errors[0].code == 399) {
-            throw new Error(AuthenticationErrors.InvalidEmail);
-        }
-
-        // Getting the flow token
-        this.flowToken = res.data['flow_token'];
-
-        // Checking the next available subtasks
-        /**
-         * This subtask has two possible outcomes.  
-         * 1. The server asks for a username next.
-         * 2. The server directly asks for password, skipping username check.
-         * 
-         * So, checking which is the subtask required by server, and executing that particular subtask.
-         */
-        for (let task of res.data.subtasks) {
-            // If next subtask is to enter username
-            if (task['subtask_id'] == 'LoginEnterAlternateIdentifierSubtask') {
-                // Executing next subtask
-                await this.enterAlternateUserIdentifier();
-
-                break;
-            }
-            // If next subtask is to enter password
-            else if (task['subtask_id'] == 'LoginEnterPassword') {
-                // Executing next subtask
-                await this.enterPassword();
-
-                break;
-            }
-        }
-    }
-
-    /**
-     * Step 4: Takes the username for login
-     * @internal
-     * 
-     * @throws {@link AuthenticationErrors.InvalidUsername}, if wrong username entered.
-     */
-    private async enterAlternateUserIdentifier(): Promise<void> {
-        // Executing the subtask
-        const res: CurlyResult = await curly.post(LoginFlows.EnterAlternateUserIdentifier.url, {
-            httpHeader: loginHeader(await this.getGuestCredentials(), this.cookies.join(';').toString()),
-            sslVerifyPeer: false,
-            postFields: JSON.stringify(LoginFlows.EnterAlternateUserIdentifier.body(this.flowToken, this.userName))
-        });
-
-        // If invalid username for the given account
-        if (res.statusCode == HttpStatus.BadRequest && res.data.errors[0].code == 399) {
-            throw new Error(AuthenticationErrors.InvalidUsername);
-        }
-
-        // Getting the flow token
-        this.flowToken = res.data['flow_token'];
-
-        // Executing next subtask
-        await this.enterPassword();
-    }
-
-    /**
-     * Step 5: Takes the password for login
-     * @internal
-     * 
-     * @throws {@link AuthenticationErrors.InvalidPassword}, incorrect password entered.
-     */
-    private async enterPassword(): Promise<void> {
-        // Executing the subtask
-        const res: CurlyResult = await curly.post(LoginFlows.EnterPassword.url, {
-            httpHeader: loginHeader(await this.getGuestCredentials(), this.cookies.join(';').toString()),
-            sslVerifyPeer: false,
-            postFields: JSON.stringify(LoginFlows.EnterPassword.body(this.flowToken, this.password))
-        });
-
-        // If invalid password for the given account
-        if (res.statusCode == HttpStatus.BadRequest && res.data.errors[0].code == 399) {
-            throw new Error(AuthenticationErrors.InvalidPassword);
-        }
-
-        // Getting the flow token
-        this.flowToken = res.data['flow_token'];
-
-        // Executing next subtask
-        await this.accountDuplicationCheck();
-    }
-
-    /**
-     * Step 6: Gets the actual cookies
-     * @internal
-     */
-    private async accountDuplicationCheck(): Promise<void> {
-        // Executing the subtask
-        const res: CurlyResult = await curly.post(LoginFlows.AccountDuplicationCheck.url, {
-            httpHeader: loginHeader(await this.getGuestCredentials(), this.cookies.join(';').toString()),
-            sslVerifyPeer: false,
-            postFields: JSON.stringify(LoginFlows.AccountDuplicationCheck.body(this.flowToken))
-        });
-
-        // Getting the cookies from the set-cookie header of the reponse.
-        this.cookies = new CookieJar().setCookies(res.headers[0]['Set-Cookie'] as string[]);
-
-        // Getting the flow token
-        this.flowToken = res.data['flow_token'];
-    }
-
-    /**
-     * Parse the authentication cookies recieved from Twitter into known format.
-     * 
-     * @internal
-     * 
-     * @param cookies The raw cookies received from Twitter.
-     * 
-     * @returns The parsed cookies of type {@link AuthCookie}
-     */
-    private parseCookies(cookies: Cookie[]): IAuthCookie {
-        /** The tempoorary parsed cookies. */
-        let tempCookies: any = {};
-
-        /**
-         * Parsing the cookies into a standard JSON format.
-         * The format is 'cookie_name': 'cookie_value'.
-         * All other cookie parameters like expiry, etc are dropped.
-         */
-        cookies.forEach(cookie => {
-            tempCookies[cookie.name] = cookie.value;
-        });
-
-        return {
-            kdt: tempCookies['kdt'],
-            twid: tempCookies['twid'],
-            ct0: tempCookies['ct0'],
-            auth_token: tempCookies['auth_token']
-        };
-    }
-
-    /**
-     * Login to Twitter using the given credentials and get back the cookies.
-     * 
-     * @public
-     * 
-     * @param email The email of the account to be logged into.
-     * @param userName The username associated with the given account.
-     * @param password The password to the account.
-     * 
-     * @returns The cookies for authenticating with the given account.
-     */
-    public async login(email: string, userName: string, password: string): Promise<IAuthCookie> {
-        /** The parsed cookies that will be returned. */
-        let parsedCookies: IAuthCookie;
-
-        // Setting user credentials
-        this.email = email;
-        this.userName = userName;
-        this.password = password;
-
-        // Initiating login
-        /**
-         * This works by sending a chain of request that are required for login to twitter.
-         * Each method in the chain returns a flow token that must be provied as payload in the next method in the chain.
-         * Each such method is called a subtask.
-         * Each subtask sets the {@link flowToken} property of the class which is used in the payload of the next subtask.
-         * The final subtask returns the headers which actually contains the cookie in the 'set-cookie' field.
-         */
-        await this.initiateLogin();
-
-        // Parsing the cookies
-        parsedCookies = this.parseCookies(this.cookies);
-
-        // Returning the final parsed cookies
-        return parsedCookies;
-    }
-}

package/src/services/auth/AuthService.ts

@@ -1,81 +0,0 @@
-// PACKAGE
-import axios from 'axios';
-
-// URLS
-import { guestTokenUrl } from '../helper/urls/Authentication';
-
-// MODELS
-import { AuthCookie } from '../../models/auth/AuthCookie';
-
-// TYPES
-import { IGuestCredentials, IAuthCredentials } from '../../types/Authentication';
-
-// CONFIGS
-import { config } from '../../config/env';
-
-/**
- * Handles authentication of http requests and other authentication related tasks.
- * 
- * @internal
- */
-export class AuthService {
-    /** The common bearer token for authentication. */
-    private authToken: string;
-
-    /** The current authentication credentials. */
-    private credentials: IAuthCredentials;
-
-    /** Whether instance has been authenticated or not. */
-    public isAuthenticated: boolean;
-
-    /**
-     * @param cookie The cookie to be used for authenticating.
-     * 
-     * @remarks
-     * 
-     * If no cookie is supplied, then guest authentication is used.
-     */
-    constructor(cookie?: AuthCookie) {
-        // Reading the auth token from the config, since it's always the same
-        this.authToken = config.twitter_auth_token;
-
-        // Setting authentication status
-        this.isAuthenticated = (cookie?.auth_token && cookie?.ct0 && cookie?.kdt && cookie?.twid) ? true : false;
-
-        // If a cookies is supplied, initializing authenticated credentials
-        if (this.isAuthenticated) {
-            // Converting the cookie from JSON to object
-            cookie = new AuthCookie(cookie);
-
-            // Setting up the authenticated credentials
-            this.credentials = { authToken: this.authToken, csrfToken: cookie.ct0, cookie: cookie.toString() };
-        }
-        // If no cookie has been supplied, initializing empty credentials
-        else {
-            // Setting up the authenticated credentials
-            this.credentials = { authToken: this.authToken, csrfToken: '', cookie: '' };
-        }
-    }
-    
-    /**
-     * @returns The current authentication credentials. A different credential is returned each time this is invoked
-     */
-    async getAuthCredentials(): Promise<IAuthCredentials> {
-        return this.credentials;
-    }
-
-    /**
-     * @returns The guest credentials fetched from twitter.
-     */
-    async getGuestCredentials(): Promise<IGuestCredentials> {
-        // Getting the guest credentials from twitter
-        return await axios.post<{ guest_token: string }>(guestTokenUrl(), null, {
-            headers: {
-                'Authorization': this.authToken
-            }
-        }).then(res => ({
-            authToken: this.authToken,
-            guestToken: res.data.guest_token
-        }));
-    }
-}

package/src/services/data/TweetService.ts

@@ -1,197 +0,0 @@
-// PACKAGES
-import {
-    Url,
-    EResourceType,
-    ITweetSearchResponse,
-    ITweetDetailsResponse,
-    ITweetFavoritersResponse,
-    ITweetRetweetersResponse,
-    ITweet as IRawTweet,
-    IUser as IRawUser,
-    TweetFilter
-} from 'rettiwt-core';
-
-// SERVICES
-import { FetcherService } from "../util/FetcherService";
-import { AuthService } from "../auth/AuthService";
-
-// MODELS
-import { Tweet } from "../../models/data/Tweet";
-import { User } from "../../models/data/User";
-import { TweetListArgs } from "../../models/args/TweetListArgs";
-import { CursoredData } from '../../models/data/CursoredData';
-
-// ENUMS
-import { AuthenticationErrors } from '../../enums/Errors';
-
-// EXTRACTORS
-import * as TweetExtractors from "../helper/extractors/Tweets";
-
-/**
- * Handles fetching of data related to tweets.
- * @public
- */
-export class TweetService extends FetcherService {
-    /**
-     * @param auth The AuthService instance to use for authentication.
-     */
-    constructor(auth: AuthService) {
-        super(auth);
-    }
-
-    /**
-     * @param filter The filter be used for searching the tweets.
-     * @param count The number of tweets to fetch, must be >= 10 (when no cursor is provided) and <= 20
-     * @param cursor The cursor to the next batch of tweets. If blank, first batch is fetched.
-     * 
-     * @returns The list of tweets that match the given filter.
-     * 
-     * @throws {@link Errors.AuthenticationErrors.NotAuthenticated} error, if no cookies have been provided.
-     * @throws {@link Errors.ValidationErrors.InvalidCount} error, if an invalid count has been provided.
-     */
-    async getTweets(query: TweetFilter, 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: TweetListArgs = new TweetListArgs(count, cursor);
-
-        // Preparing the URL
-        const url: string = new Url(EResourceType.TWEET_SEARCH, { filter: query, count: args.count, cursor: args.cursor }).toString();
-
-        // Getting the raw data
-        let res = await this.request<ITweetSearchResponse>(url).then(res => res.data);
-
-        // Extracting data
-        let data = TweetExtractors.extractTweets(res);
-
-        // Caching data
-        this.cacheData(data);
-
-        // Parsing data
-        let tweets = data.required.map((item: IRawTweet) => new Tweet(item));
-
-        // Sorting the tweets by date, from recent to oldest
-        tweets.sort((a, b) => new Date(b.createdAt).valueOf() - new Date(a.createdAt).valueOf());
-
-        return new CursoredData<Tweet>(tweets, data.cursor);
-    }
-
-    /**
-     * @param id The id of the target tweet.
-     * 
-     * @returns The details of a single tweet with the given tweet id.
-     * 
-     * @throws {@link Errors.AuthenticationErrors.NotAuthenticated} error, if no cookies have been provided.
-     * @throws {@link Errors.DataErrors.TweetNotFound} error, if no tweet with the given id was found.
-     */
-    async getTweetDetails(id: string): Promise<Tweet> {
-        // If user is not authenticated, abort
-        if (!this.isAuthenticated) {
-            throw new Error(AuthenticationErrors.NotAuthenticated);
-        }
-
-        // Getting data from cache
-        let cachedData = await this.readData(id);
-
-        // If data exists in cache
-        if (cachedData) {
-            return cachedData;
-        }
-
-        // Preparing the URL
-        const url: string = new Url(EResourceType.TWEET_DETAILS, { id: id }).toString();
-
-        // Fetching the raw data
-        let res = await this.request<ITweetDetailsResponse>(url).then(res => res.data);
-
-        // Extracting data
-        let data = TweetExtractors.extractTweet(res, id);
-
-        // Caching data
-        this.cacheData(data);
-
-        // Parsing data
-        let tweet = new Tweet(data.required[0]);
-
-        return tweet;
-    }
-
-    /**
-     * @param tweetId The rest id of the target tweet.
-     * @param count The batch size of the list, must be >= 10 (when no cursor is provided) and <= 20.
-     * @param cursor The cursor to the next batch of users. If blank, first batch is fetched.
-     * 
-     * @returns The list of users who liked the given tweet.
-     * 
-     * @throws {@link Errors.AuthenticationErrors.NotAuthenticated} error, if no cookies have been provided.
-     * @throws {@link Errors.ValidationErrors.InvalidCount} error, if invalid count is provided.
-     * @throws {@link Errors.DataErrors.TweetNotFound} error, if no tweet with the given id was found.
-     */
-    async getTweetLikers(tweetId: 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: TweetListArgs = new TweetListArgs(count, cursor);
-
-        // Preparing the URL
-        const url: string = new Url(EResourceType.TWEET_FAVORITERS, { id: tweetId, count: args.count, cursor: args.cursor }).toString();
-
-        // Fetching the raw data
-        let res = await this.request<ITweetFavoritersResponse>(url).then(res => res.data);
-
-        // Extracting data
-        let data = TweetExtractors.extractTweetLikers(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 tweetId The rest id of the target tweet.
-     * @param count The batch size of the list, must be >= 10 (when no cursor is provided) and <= 100.
-     * @param cursor The cursor to the next batch of users. If blank, first batch is fetched.
-     * 
-     * @returns The list of users who retweeted the given tweet.
-     * 
-     * @throws {@link Errors.AuthenticationErrors.NotAuthenticated} error, if no cookies have been provided.
-     * @throws {@link Errors.ValidationErrors.InvalidCount} error, if invalid count is provided.
-     * @throws {@link Errors.DataErrors.TweetNotFound} error, if no tweet with the given id was found.
-     */
-    async getTweetRetweeters(tweetId: 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: TweetListArgs = new TweetListArgs(count, cursor);
-
-        // Preparing the URL
-        const url: string = new Url(EResourceType.TWEET_RETWEETERS, { id: tweetId, count: args.count, cursor: args.cursor }).toString();
-
-        // Fetching the raw data
-        let res = await this.request<ITweetRetweetersResponse>(url).then(res => res.data);
-
-        // Extracting data
-        let data = TweetExtractors.extractTweetRetweeters(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);
-    }
-}