rettiwt-api 1.0.5 → 1.0.7

package/src/services/FetcherService.ts

@@ -12,7 +12,17 @@ import { Result as RawTweet } from '../types/raw/tweet/Tweet';
 
 // HELPERS
 import * as Headers from './helper/Headers'
-import * as Deserializers from './helper/Deserializers';
+import * as UserDeserializers from './helper/deserializers/Users';
+import * as TweetDeserializers from './helper/deserializers/Tweets';
+import { CurlyOptions } from 'node-libcurl/dist/curly';
+
+/**
+ * @summary Stores all the different type of http requests
+ */
+export enum HttpMethods {
+    POST = "POST",
+    GET = "GET"
+};
 
 /**
  * @service The base serivice from which all other data services derive their behaviour
@@ -20,11 +30,13 @@ import * as Deserializers from './helper/Deserializers';
 export class FetcherService {
     // MEMBER DATA
     private auth: AuthService;                                              // To store the auth service instance to use for authentication
+    private cache: CacheService;                                            // To stoer the cache service instance to use for caching data
     protected isAuthenticated: boolean;                                     // To store whether user is authenticated or not
 
     // MEMBER METHODS
     constructor(auth: AuthService) {
         this.auth = auth;
+        this.cache = CacheService.getInstance();
         this.isAuthenticated = this.auth.isAuthenticated;
     }
 
@@ -43,44 +55,47 @@ export class FetcherService {
     /**
      * @returns The absolute raw json data from give url
      * @param url The url to fetch data from
-     * @param authenticated Whether to authenticate requests or not
+     * @param authenticate Whether to authenticate requests or not
+     * @param method The HTTP method to use
+     * @param data The data to be sent along with the request (works with only POST method)
      */
-    protected async request<DataType>(url: string, authenticated: boolean = true): Promise<CurlyResult<DataType>> {
-        // Fetching the data
-        let res = await curly.get(url, {
-            httpHeader: authenticated ? Headers.authorizedHeader(await this.auth.getAuthCredentials()) : Headers.guestHeader(await this.auth.getGuestCredentials()),
-            sslVerifyPeer: false
-        }).then(res => this.handleHTTPError(res));
+    protected async request<DataType>(url: string, authenticate: boolean = true, method: HttpMethods = HttpMethods.GET, data?: any): Promise<CurlyResult<DataType>> {
+        // Creating the configuration for the http request
+        let config: CurlyOptions = {
+            httpHeader: authenticate ? Headers.authorizedHeader(await this.auth.getAuthCredentials()) : Headers.guestHeader(await this.auth.getGuestCredentials()),
+            sslVerifyPeer: false,
+        };
 
-        return res;
+        // If post request is to be made
+        if (method == HttpMethods.POST) {
+            return await curly.post(url, { ...config, postFields: JSON.stringify(data) }).then(res => this.handleHTTPError(res));
+        }
+        // If get request is to be made
+        else {
+            return await curly.get(url, config).then(res => this.handleHTTPError(res));
+        }
     }
 
     /**
      * @summary Caches the extracted data
      * @param data The extracted data to be cached
      */
-    protected async cacheData(data: any): Promise<void> {
-        // Creating an instance of cache
-        let cache = await CacheService.getInstance();
-
+    protected cacheData(data: any): void {
         // Parsing the extracted data
-        let users = data.users.map((user: RawUser) => Deserializers.toUser(user));
-        let tweets = data.tweets.map((tweet: RawTweet) => Deserializers.toTweet(tweet));
+        let users = data.users.map((user: RawUser) => UserDeserializers.toUser(user));
+        let tweets = data.tweets.map((tweet: RawTweet) => TweetDeserializers.toTweet(tweet));
 
         // Caching the data
-        cache.write(users);
-        cache.write(tweets);
+        this.cache.write(users);
+        this.cache.write(tweets);
     }
 
     /**
      * @returns The data with the given id (if it exists in cache)
      * @param id The id of the data to be read from cache
      */
-    protected async readData(id: string): Promise<any> {
-        // Creating an instance of cache
-        let cache = await CacheService.getInstance();
-
+    protected readData(id: string): any {
         // Reading data from cache
-        return cache.read(id);
+        return this.cache.read(id);
     }
 }

package/src/services/accounts/AccountService.ts

@@ -0,0 +1,156 @@
+// PACKAGES
+import { curly, CurlyResult } from 'node-libcurl';
+
+// SERVICES
+import { AuthService } from '../AuthService';
+
+// TYPES
+import { GuestCredentials } from '../../types/Authentication';
+
+// HELPERS
+import LoginFlows from './LoginFlows';
+import { loginHeader } from '../helper/Headers';
+import { Cookie, CookieJar } from 'cookiejar';
+
+export class AccountService {
+    // MEMBER DATA
+    private auth: AuthService;                                                  // To store the auth service instance to use
+    private guestCreds: GuestCredentials;                                       // To store the guest credentials to use
+    private cookies: Cookie[];                                                  // To store the cookies received from twitter
+    private flowToken: string;                                                  // To store the flow token received from current flow
+
+    // MEMBER METHODS
+    constructor() {
+        this.auth = new AuthService();
+        this.guestCreds = { authToken: '', guestToken: '' };
+        this.cookies = [];
+        this.flowToken = '';
+    }
+
+    /**
+     * @returns The current guest credentials to use. If if does not exists, then a new one is created
+     */
+    private async getGuestCredentials(): Promise<GuestCredentials> {
+        // 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;
+    }
+
+    /**
+     * @summary Step 1: Initiates login
+     */
+    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'];
+    }
+
+    /**
+     * @summary Step 2: Does something
+     */
+    private async jsInstrumentationSubtask(): Promise<void> {
+        // Executing the flow
+        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'];
+    }
+
+    /**
+     * @summary Step 3: Takes the email for login
+     */
+    private async enterUserIdentifier(email: string): Promise<void> {
+        // Executing the flow
+        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, email))
+        });
+
+        // Getting the flow token
+        this.flowToken = res.data['flow_token'];
+    }
+
+    /**
+     * @summary Step 4: Takes the username for login
+     */
+    private async enterAlternateUserIdentifier(userName: string): Promise<void> {
+        // Executing the flow
+        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, userName))
+        });
+
+        // Getting the flow token
+        this.flowToken = res.data['flow_token'];
+    }
+
+    /**
+     * @summary Step 5: Takes the password for login
+     */
+    private async enterPassword(password: string): Promise<void> {
+        // Executing the flow
+        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, password))
+        });
+
+        // Getting the flow token
+        this.flowToken = res.data['flow_token'];
+    }
+
+    /**
+     * @summary Step 6: Gets the actual cookies
+     */
+    private async accountDuplicationCheck(): Promise<void> {
+        // Executing the flow
+        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))
+        });
+
+        // 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'];
+    }
+
+    /**
+     * @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<string> {
+        // Executing each step of login flow
+        await this.initiateLogin();
+        await this.jsInstrumentationSubtask();
+        await this.enterUserIdentifier(email);
+        await this.enterAlternateUserIdentifier(userName);
+        await this.enterPassword(password);
+        await this.accountDuplicationCheck();
+        
+        // Returning the final cookies
+        return this.cookies.join(';');
+    }
+}

package/src/services/accounts/LoginFlows.ts

@@ -0,0 +1,90 @@
+const LoginFlows = {
+    "InitiateLogin": {
+        url: 'https://api.twitter.com/1.1/onboarding/task.json?flow_name=login'
+    },
+    "JsInstrumentationSubtask": {
+        url: 'https://api.twitter.com/1.1/onboarding/task.json',
+        body: (flowToken: string) => ({
+            "flow_token": flowToken,
+            "subtask_inputs": [
+                {
+                    "subtask_id": "LoginJsInstrumentationSubtask",
+                    "js_instrumentation": {
+                        "response": "{\"rf\":{\"a09453c7341fb1cbb7d51561f92d478fa0752bc77e7ca6b5703258680b2c51d7\":-4,\"bd26c6694e256b10766447d992deaf92bb220bc05e3b8205ba5c9a4f83302230\":0,\"abfa440376b8dc33ca518e1e2a998b3ac4200a8122ef09781eea2c1408717111\":-1,\"a4e87b66027f638a4634561275fab00f9f7446b81a180b5f03eda69fa32eb8f4\":-224},\"s\":\"yET9nlXrlGRAylCyyBKEsxOpUweMpjRz5RfKzTzQyVADnKE64gmpyILfKBK0-HIHWY8FbJPHGWr6QrCb5A-Z3q2SLRm4DReprZGXykJ111_ynet8kSjFkRjODKKDN2FzT1V6rx9FILnUuRCaMu9ewfPgPBi4wO1g7EUeEsSSHIiCwNc9URJr4c2xVTA3ibIfTbu8p2WhX7RZAk8LWRPpPPB21st8Z1j0LcLlR0bkZoF6LsN-7w75lGB0s4z1JKqus2MVuRcPMay0wWZbn8Qx9In_-tSTvEBLcxjUpDgwu29G0g0iCWoISFzLY4-LLvV7UBGklkByIcPtwYbDbREqRQAAAYYmXAsG\"}",
+                        "link": "next_link"
+                    }
+                }
+            ]
+        })
+    },
+    "EnterUserIdentifier": {
+        url: 'https://api.twitter.com/1.1/onboarding/task.json',
+        body: (flowToken: string, email: string) => ({
+            "flow_token": flowToken,
+            "subtask_inputs": [
+                {
+                    "subtask_id": "LoginEnterUserIdentifierSSO",
+                    "settings_list": {
+                        "setting_responses": [
+                            {
+                                "key": "user_identifier",
+                                "response_data": {
+                                    "text_data": {
+                                        "result": email
+                                    }
+                                }
+                            }
+                        ],
+                        "link": "next_link"
+                    }
+                }
+            ]
+        })
+    },
+    "EnterAlternateUserIdentifier": {
+        url: 'https://api.twitter.com/1.1/onboarding/task.json',
+        body: (flowToken: string, userName: string) => ({
+            "flow_token": flowToken,
+            "subtask_inputs": [
+                {
+                    "subtask_id": "LoginEnterAlternateIdentifierSubtask",
+                    "enter_text": {
+                        "text": userName,
+                        "link": "next_link"
+                    }
+                }
+            ]
+        })
+    },
+    "EnterPassword": {
+        url: 'https://api.twitter.com/1.1/onboarding/task.json',
+        body: (flowToken: string, password: string) => ({
+            "flow_token": flowToken,
+            "subtask_inputs": [
+                {
+                    "subtask_id": "LoginEnterPassword",
+                    "enter_password": {
+                        "password": password,
+                        "link": "next_link"
+                    }
+                }
+            ]
+        })
+    },
+    "AccountDuplicationCheck": {
+        url: 'https://api.twitter.com/1.1/onboarding/task.json',
+        body: (flowToken: string) => ({
+            "flow_token": flowToken,
+            "subtask_inputs": [
+                {
+                    "subtask_id": "AccountDuplicationCheck",
+                    "check_logged_in_account": {
+                        "link": "AccountDuplicationCheck_false"
+                    }
+                }
+            ]
+        })
+    }
+}
+
+export default LoginFlows;

package/src/services/data/TweetService.ts

@@ -3,22 +3,25 @@ import { FetcherService } from "../FetcherService";
 import { AuthService } from "../AuthService";
 
 // TYPES
-import { TweetFilter, Tweet } from "../../types/Tweet";
-import { User } from "../../types/UserAccount";
-import { CursoredData } from '../../types/Service';
-import RawTweet from '../../types/raw/tweet/Tweet';
+import { TweetFilter, Tweet } from "../../types/data/Tweet";
+import { User } from "../../types/data/User";
+import { CursoredData } from '../../types/data/Service';
+import RawTweet, { Result as TweetData } from '../../types/raw/tweet/Tweet';
+import { Result as UserData } from "../../types/raw/user/User";
 import RawTweets from '../../types/raw/tweet/Tweets';
 import RawLikers from '../../types/raw/tweet/Favouriters';
 import RawRetweeters from '../../types/raw/tweet/Retweeters';
+import * as Errors from '../../types/data/Errors';
 
 // URLS
-import * as Urls from '../helper/Urls';
+import * as TweetUrls from '../helper/urls/Tweets';
 
 // EXTRACTORS
-import * as Extractors from "../helper/Extractors";
+import * as TweetExtractors from "../helper/extractors/Tweets";
 
 // DESERIALIZERS
-import * as Deserializers from '../helper/Deserializers';
+import * as UserDeserializers from '../helper/deserializers/Users';
+import * as TweetDeserializers from '../helper/deserializers/Tweets';
 
 // PARSERS
 import { toQueryString } from '../helper/Parser';
@@ -35,21 +38,26 @@ export class TweetService extends FetcherService {
     /**
      * @returns The list of tweets that match the given filter
      * @param filter The filter be used for searching the tweets
-     * @param count The number of tweets to fetch
+     * @param count The number of tweets to fetch, must be >= 1 and <= 100
      * @param cursor The cursor to the next batch of tweets. If blank, first batch is fetched
      */
     async getTweets(filter: TweetFilter, count: number, cursor: string): Promise<CursoredData<Tweet>> {
+        // If invalid count provided
+        if (count < 1 && !cursor) {
+            throw new Error(Errors.ValidationErrors.InvalidCount);
+        }
+
         // Getting the raw data
-        let res = await this.request<RawTweets>(Urls.tweetsUrl(toQueryString(filter), count, cursor), false).then(res => res.data);
+        let res = await this.request<RawTweets>(TweetUrls.tweetsUrl(toQueryString(filter), count, cursor), false).then(res => res.data);
 
         // Extracting data
-        let data = Extractors.extractTweets(res);
+        let data = TweetExtractors.extractTweets(res);
 
         // Caching data
         this.cacheData(data);
 
         // Parsing data
-        let tweets = data.required.map(item => Deserializers.toTweet(item));
+        let tweets = data.required.map((item: TweetData) => TweetDeserializers.toTweet(item));
 
         return {
             list: tweets,
@@ -69,47 +77,50 @@ export class TweetService extends FetcherService {
         if (cachedData) {
             return cachedData;
         }
-        // If data does not exist in cache
-        else {
-            // Fetching the raw data
-            let res = await this.request<RawTweet>(Urls.tweetDetailsUrl(tweetId), false).then(res => res.data);
+        
+        // Fetching the raw data
+        let res = await this.request<RawTweet>(TweetUrls.tweetDetailsUrl(tweetId), false).then(res => res.data);
 
-            // Extracting data
-            let data = Extractors.extractTweet(res, tweetId);
+        // Extracting data
+        let data = TweetExtractors.extractTweet(res, tweetId);
 
-            // Caching data
-            this.cacheData(data);
+        // Caching data
+        this.cacheData(data);
 
-            // Parsing data
-            let tweet = Deserializers.toTweet(data.required[0]);
+        // Parsing data
+        let tweet = TweetDeserializers.toTweet(data.required[0]);
 
-            return tweet;
-        }
+        return tweet;
     }
 
     /**
      * @returns The list of users who liked the given tweet
      * @param tweetId The rest id of the target tweet
-     * @param count The batch size of the list
+     * @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
      */
     async getTweetLikers(tweetId: string, count: number, cursor: string): Promise<CursoredData<User>> {
         // If user is not authenticated, abort
         if(!this.isAuthenticated) {
-            return { error: new Error('Cannot fetch tweet likes without authentication!') };
+            throw new Error(Errors.AuthenticationErrors.NotAuthenticated);
+        }
+
+        // If invalid count provided
+        if (count < 10 && !cursor) {
+            throw new Error(Errors.ValidationErrors.InvalidCount);
         }
         
         // Fetching the raw data
-        let res = await this.request<RawLikers>(Urls.tweetLikesUrl(tweetId, count, cursor)).then(res => res.data);
+        let res = await this.request<RawLikers>(TweetUrls.tweetLikesUrl(tweetId, count, cursor)).then(res => res.data);
 
         // Extracting data
-        let data = Extractors.extractTweetLikers(res);
+        let data = TweetExtractors.extractTweetLikers(res);
 
         // Caching data
         this.cacheData(data);
 
         // Parsing data
-        let users = data.required.map(item => Deserializers.toUser(item));
+        let users = data.required.map((item: UserData) => UserDeserializers.toUser(item));
 
         return {
             list: users,
@@ -120,26 +131,31 @@ export class TweetService extends FetcherService {
     /**
      * @returns The list of users who retweeted the given tweet     
      * @param tweetId The rest id of the target tweet
-     * @param count The batch size of the list
+     * @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
      */
     async getTweetRetweeters(tweetId: string, count: number, cursor: string): Promise<CursoredData<User>> {
         // If user is not authenticated, abort
         if(!this.isAuthenticated) {
-            return { error: new Error('Cannot fetch tweet retweeters without authentication!') };
+            throw new Error(Errors.AuthenticationErrors.NotAuthenticated);
+        }
+
+        // If invalid count provided
+        if (count < 10 && !cursor) {
+            throw new Error(Errors.ValidationErrors.InvalidCount);
         }
 
         // Fetching the raw data
-        let res = await this.request<RawRetweeters>(Urls.tweetRetweetUrl(tweetId, count, cursor)).then(res => res.data);
+        let res = await this.request<RawRetweeters>(TweetUrls.tweetRetweetUrl(tweetId, count, cursor)).then(res => res.data);
 
         // Extracting data
-        let data = Extractors.extractTweetRetweeters(res);
+        let data = TweetExtractors.extractTweetRetweeters(res);
 
         // Caching data
         this.cacheData(data);
 
         // Parsing data
-        let users = data.required.map(item => Deserializers.toUser(item));
+        let users = data.required.map((item: UserData) => UserDeserializers.toUser(item));
 
         return {
             list: users,
@@ -155,20 +171,20 @@ export class TweetService extends FetcherService {
     async getTweetReplies(tweetId: string, cursor: string): Promise<CursoredData<Tweet>> {
         // If user is not authenticated, abort
         if(!this.isAuthenticated) {
-            return { error: new Error('Cannot fetch tweet replies without authentication!') };
+            throw new Error(Errors.AuthenticationErrors.NotAuthenticated);
         }
 
         // Fetching the raw data
-        let res = await this.request<RawTweet>(Urls.tweetRepliesUrl(tweetId, cursor)).then(res => res.data);
+        let res = await this.request<RawTweet>(TweetUrls.tweetRepliesUrl(tweetId, cursor)).then(res => res.data);
 
         // Extracting data
-        let data = Extractors.extractTweetReplies(res, tweetId);
+        let data = TweetExtractors.extractTweetReplies(res, tweetId);
 
         // Caching data
         this.cacheData(data);
 
         // Parsing data
-        let tweets = data.required.map(item => Deserializers.toTweet(item));
+        let tweets = data.required.map((item: TweetData) => TweetDeserializers.toTweet(item));
 
         return {
             list: tweets,