rettiwt-api 1.1.7 → 1.2.0

package/src/services/auth/AccountService.ts

@@ -22,23 +22,25 @@ import { Cookie, CookieJar } from 'cookiejar';
  */
 export class AccountService {
     /** The AuthService instance to use for authentication. */
-    private auth: AuthService;
-    
+    private auth: AuthService = new AuthService();
+
     /** The current guest credentials to use. */
-    private guestCreds: IGuestCredentials;
+    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[];
+    private cookies: Cookie[] = [];
 
     /** The flow token received after execution of current flow. */
-    private flowToken: string;
-
-    constructor() {
-        this.auth = new AuthService();
-        this.guestCreds = { authToken: '', guestToken: '' };
-        this.cookies = [];
-        this.flowToken = '';
-    }
+    private flowToken: string = '';
 
     /**
      * @returns The current guest credentials to use. If if does not exists, then a new one is created
@@ -69,6 +71,9 @@ export class AccountService {
 
         // Getting the flow token
         this.flowToken = res.data['flow_token'];
+
+        // Executing next subtask
+        await this.jsInstrumentationSubtask();
     }
 
     /**
@@ -76,7 +81,7 @@ export class AccountService {
      * @internal
      */
     private async jsInstrumentationSubtask(): Promise<void> {
-        // Executing the flow
+        // Executing the subtask
         const res: CurlyResult = await curly.post(LoginFlows.JsInstrumentationSubtask.url, {
             httpHeader: loginHeader(await this.getGuestCredentials(), this.cookies.join(';').toString()),
             sslVerifyPeer: false,
@@ -85,6 +90,9 @@ export class AccountService {
 
         // Getting the flow token
         this.flowToken = res.data['flow_token'];
+
+        // Executing next subtask
+        await this.enterUserIdentifier();
     }
 
     /**
@@ -93,12 +101,12 @@ export class AccountService {
      * 
      * @throws {@link AuthenticationErrors.InvalidEmail}, if email does not exist.
      */
-    private async enterUserIdentifier(email: string): Promise<void> {
-        // Executing the flow
+    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, email))
+            postFields: JSON.stringify(LoginFlows.EnterUserIdentifier.body(this.flowToken, this.email))
         });
 
         // If no account found with given email
@@ -108,6 +116,31 @@ export class AccountService {
 
         // 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;
+            }
+        }
     }
 
     /**
@@ -116,12 +149,12 @@ export class AccountService {
      * 
      * @throws {@link AuthenticationErrors.InvalidUsername}, if wrong username entered.
      */
-    private async enterAlternateUserIdentifier(userName: string): Promise<void> {
-        // Executing the flow
+    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, userName))
+            postFields: JSON.stringify(LoginFlows.EnterAlternateUserIdentifier.body(this.flowToken, this.userName))
         });
 
         // If invalid username for the given account
@@ -131,6 +164,9 @@ export class AccountService {
 
         // Getting the flow token
         this.flowToken = res.data['flow_token'];
+
+        // Executing next subtask
+        await this.enterPassword();
     }
 
     /**
@@ -139,12 +175,12 @@ export class AccountService {
      * 
      * @throws {@link AuthenticationErrors.InvalidPassword}, incorrect password entered.
      */
-    private async enterPassword(password: string): Promise<void> {
-        // Executing the flow
+    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, password))
+            postFields: JSON.stringify(LoginFlows.EnterPassword.body(this.flowToken, this.password))
         });
 
         // If invalid password for the given account
@@ -154,6 +190,9 @@ export class AccountService {
 
         // Getting the flow token
         this.flowToken = res.data['flow_token'];
+
+        // Executing next subtask
+        await this.accountDuplicationCheck();
     }
 
     /**
@@ -161,7 +200,7 @@ export class AccountService {
      * @internal
      */
     private async accountDuplicationCheck(): Promise<void> {
-        // Executing the flow
+        // Executing the subtask
         const res: CurlyResult = await curly.post(LoginFlows.AccountDuplicationCheck.url, {
             httpHeader: loginHeader(await this.getGuestCredentials(), this.cookies.join(';').toString()),
             sslVerifyPeer: false,
@@ -175,31 +214,6 @@ export class AccountService {
         this.flowToken = res.data['flow_token'];
     }
 
-    /**
-     * Execute all the flows required to login to Twitter, using the given credentials, then set the response cookies.
-     * 
-     * @internal
-     * 
-     * @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.
-     */
-    private async executeLoginFlows(email: string, userName: string, password: string): Promise<void> {
-        /**
-         * 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 then given 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();
-        await this.jsInstrumentationSubtask();
-        await this.enterUserIdentifier(email);
-        await this.enterAlternateUserIdentifier(userName);
-        await this.enterPassword(password);
-        await this.accountDuplicationCheck(); 
-    }
-
     /**
      * Parse the authentication cookies recieved from Twitter into known format.
      * 
@@ -212,7 +226,7 @@ export class AccountService {
     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'.
@@ -244,13 +258,25 @@ export class AccountService {
     public async login(email: string, userName: string, password: string): Promise<IAuthCookie> {
         /** The parsed cookies that will be returned. */
         let parsedCookies: IAuthCookie;
-        
-        // Executing all login flows
-        await this.executeLoginFlows(email, userName, password);
+
+        // 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/data/TweetService.ts

@@ -3,6 +3,7 @@ import { FetcherService } from "../util/FetcherService";
 import { AuthService } from "../auth/AuthService";
 
 // MODELS
+import { Url } from '../../twitter/Url';
 import { Tweet } from "../../models/data/Tweet";
 import { User } from "../../models/data/User";
 import { TweetListArgs } from "../../models/args/TweetListArgs";
@@ -10,24 +11,19 @@ import { TweetFilter } from "../../models/args/TweetFilter";
 import { CursoredData } from '../../models/data/CursoredData';
 
 // TYPES
-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 RawTweet, { Result as TweetData } from '../../twitter/types/tweet/Tweet';
+import { Result as UserData } from "../../twitter/types/user/User";
+import RawTweets from '../../twitter/types/tweet/Tweets';
+import RawLikers from '../../twitter/types/tweet/Favouriters';
+import RawRetweeters from '../../twitter/types/tweet/Retweeters';
 
 // ENUMS
+import { ResourceType } from '../../twitter/enums/Resources';
 import { AuthenticationErrors } from '../../enums/Errors';
 
-// URLS
-import * as TweetUrls from '../helper/urls/Tweets';
-
 // EXTRACTORS
 import * as TweetExtractors from "../helper/extractors/Tweets";
 
-// PARSERS
-import { toQueryString } from '../helper/Parser';
-
 /**
  * Handles fetching of data related to tweets.
  * @public
@@ -47,19 +43,24 @@ export class TweetService extends FetcherService {
      * 
      * @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.
-     * 
-     * @remarks
-     * 
-     * Cookies are required to use this method!
      */
     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 filter: TweetFilter = new TweetFilter(query);
         let args: TweetListArgs = new TweetListArgs(count, cursor);
 
+        // Preparing the URL
+        const url: string = new Url(ResourceType.TWEETS, { query: filter.toString(), count: args.count, cursor: args.cursor }).toString();
+
         // Getting the raw data
-        let res = await this.request<RawTweets>(TweetUrls.tweetsUrl(toQueryString(filter), args.count, args.cursor), this.isAuthenticated).then(res => res.data);
+        let res = await this.request<RawTweets>(url).then(res => res.data);
 
         // Extracting data
         let data = TweetExtractors.extractTweets(res);
@@ -81,13 +82,15 @@ export class TweetService extends FetcherService {
      * 
      * @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.
-     * 
-     * @remarks
-     * 
-     * No cookies are required to use this method.
      */
     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);
 
@@ -96,8 +99,11 @@ export class TweetService extends FetcherService {
             return cachedData;
         }
 
+        // Preparing the URL
+        const url: string = new Url(ResourceType.TWEET_DETAILS, { id: id }).toString();
+
         // Fetching the raw data
-        let res = await this.request<RawTweet>(TweetUrls.tweetDetailsUrl(id), false).then(res => res.data);
+        let res = await this.request<RawTweet>(url).then(res => res.data);
 
         // Extracting data
         let data = TweetExtractors.extractTweet(res, id);
@@ -121,10 +127,6 @@ export class TweetService extends FetcherService {
      * @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.
-     * 
-     * @remarks
-     * 
-     * Cookies are required to use this method!
      */
     async getTweetLikers(tweetId: string, count?: number, cursor?: string): Promise<CursoredData<User>> {
         // If user is not authenticated, abort
@@ -135,8 +137,11 @@ export class TweetService extends FetcherService {
         // Objectifying parameters
         let args: TweetListArgs = new TweetListArgs(count, cursor);
 
+        // Preparing the URL
+        const url: string = new Url(ResourceType.TWEET_LIKES, { id: tweetId, count: args.count, cursor: args.cursor }).toString();
+
         // Fetching the raw data
-        let res = await this.request<RawLikers>(TweetUrls.tweetLikesUrl(tweetId, args.count, args.cursor)).then(res => res.data);
+        let res = await this.request<RawLikers>(url).then(res => res.data);
 
         // Extracting data
         let data = TweetExtractors.extractTweetLikers(res);
@@ -160,10 +165,6 @@ export class TweetService extends FetcherService {
      * @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.
-     * 
-     * @remarks
-     * 
-     * Cookies are required to use this method!
      */
     async getTweetRetweeters(tweetId: string, count?: number, cursor?: string): Promise<CursoredData<User>> {
         // If user is not authenticated, abort
@@ -174,8 +175,11 @@ export class TweetService extends FetcherService {
         // Objectifying parameters
         let args: TweetListArgs = new TweetListArgs(count, cursor);
 
+        // Preparing the URL
+        const url: string = new Url(ResourceType.TWEET_RETWEETS, { id: tweetId, count: args.count, cursor: args.cursor }).toString();
+
         // Fetching the raw data
-        let res = await this.request<RawRetweeters>(TweetUrls.tweetRetweetUrl(tweetId, args.count, args.cursor)).then(res => res.data);
+        let res = await this.request<RawRetweeters>(url).then(res => res.data);
 
         // Extracting data
         let data = TweetExtractors.extractTweetRetweeters(res);
@@ -188,38 +192,4 @@ export class TweetService extends FetcherService {
 
         return new CursoredData<User>(users, data.cursor);
     }
-
-    /**
-     * THIS IS DISABLED FOR USE FOR NOW BECAUSE TWITTER DOESN'T HAVE ANY ENDPOINT FOR FETCHING REPLIES.
-     * THE DATA THIS RETURNS IS INCONSISTENT!
-     * 
-     * @param tweetId The rest id of the target tweet.
-     * @param cursor The cursor to the next batch of replies. If blank, first batch is fetched.
-     * @returns The list of replies to the given tweet.
-     */
-    /*
-    async getTweetReplies(tweetId: string, cursor: string): Promise<CursoredData<Tweet>> {
-        // If user is not authenticated, abort
-        if(!this.isAuthenticated) {
-            throw new Error(Errors.AuthenticationErrors.NotAuthenticated);
-        }
-
-        // Fetching the raw data
-        let res = await this.request<RawTweet>(TweetUrls.tweetRepliesUrl(tweetId, cursor)).then(res => res.data);
-
-        // Extracting data
-        let data = TweetExtractors.extractTweetReplies(res, tweetId);
-
-        // 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/data/UserService.ts

@@ -3,27 +3,26 @@ import { FetcherService } from '../util/FetcherService';
 import { AuthService } from '../auth/AuthService';
 
 // MODELS
+import { Url } from '../../twitter/Url';
 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';
-import { Result as TweetData } from '../../types/raw/tweet/Tweet';
-import RawUser, { Result as UserData } from '../../types/raw/user/User';
-import RawUserTweets from '../../types/raw/user/Tweets';
-import RawUserFollowers from '../../types/raw/user/Followers';
-import RawUserFollowing from '../../types/raw/user/Following';
-import RawUserLikes from '../../types/raw/user/Likes';
+import { Result as TweetData } from '../../twitter/types/tweet/Tweet';
+import RawUser, { Result as UserData } from '../../twitter/types/user/User';
+import RawUserFollowers from '../../twitter/types/user/Followers';
+import RawUserFollowing from '../../twitter/types/user/Following';
+import RawUserLikes from '../../twitter/types/user/Likes';
 
 // ENUMS
+import { ResourceType } from '../../twitter/enums/Resources';
 import { AuthenticationErrors } from '../../enums/Errors';
 
-// URLS
-import * as UserUrls from '../helper/urls/Users';
-
 // EXTRACTORS
 import * as UserExtractors from '../helper/extractors/Users';
+import { TweetService } from './TweetService';
 
 /**
  * Handles fetching of data related to user account
@@ -41,19 +40,24 @@ export class UserService extends FetcherService {
      * 
      * @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.
-     * 
-     * @remarks
-     * 
-     * No cookies are required to use this method.
      */
     async getUserDetails(id: string): Promise<User> {
+        // If user is not authenticated, abort
+        if (!this.isAuthenticated) {
+            throw new Error(AuthenticationErrors.NotAuthenticated);
+        }
+
         let res: RawUser;
 
         // If id is not a numeric string => username is supplied
         if (isNaN(Number(id))) {
+            // Preparing the URL
+            const url: string = new Url(ResourceType.USER_DETAILS, { id: id }).toString();
+
             // Fetching the raw data
-            res = await this.request<RawUser>(UserUrls.userDetailsUrl(id), false).then(res => res.data);
+            res = await this.request<RawUser>(url).then(res => res.data);
         }
         // If id is a numeric string => id is supplied
         else {
@@ -65,8 +69,11 @@ export class UserService extends FetcherService {
                 return cachedData;
             }
 
+            // Preparing the URL
+            const url: string = new Url(ResourceType.USER_DETAILS_BY_ID, { id: id }).toString();
+
             // Fetching the raw data
-            res = await this.request<RawUser>(UserUrls.userDetailsByIdUrl(id), false).then(res => res.data);
+            res = await this.request<RawUser>(url).then(res => res.data);
         }
 
         // Extracting data
@@ -88,30 +95,20 @@ export class UserService extends FetcherService {
      * 
      * @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.
      * 
-     * @remarks
-     * 
-     * No cookies are required to use this method.
+     * @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>> {
-        // Objectifying parameters
-        let args: UserListArgs = new UserListArgs(count, cursor);
-
-        // Fetching the raw data
-        let res = await this.request<RawUserTweets>(UserUrls.userTweetsUrl(userId, args.count, args.cursor), false).then(res => res.data);
+        // Getting the username of the target user
+        const userName: string = (await this.getUserDetails(userId)).userName;
 
-        // Extracting data
-        let data = UserExtractors.extractUserTweets(res);
-
-        // Caching data
-        this.cacheData(data);
-
-        // Parsing data
-        let tweets = data.required.map((item: TweetData) => new Tweet(item));
-
-        return new CursoredData<Tweet>(tweets, data.cursor);
+        // Getting the tweets of the target user
+        return new TweetService(this.auth).getTweets({
+            fromUsers: [userName]
+        }, count, cursor);
     }
 
     /**
@@ -124,10 +121,6 @@ export class UserService extends FetcherService {
      * @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.
-     * 
-     * @remarks
-     * 
-     * Cookies are required to use this method!
      */
     async getUserFollowing(userId: string, count?: number, cursor?: string): Promise<CursoredData<User>> {
         // If user is not authenticated, abort
@@ -138,8 +131,11 @@ export class UserService extends FetcherService {
         // Objectifying parameters
         let args: UserListArgs = new UserListArgs(count, cursor);
 
+        // Preparing the URL
+        const url: string = new Url(ResourceType.USER_FOLLOWING, { id: userId, count: args.count, cursor: args.cursor }).toString();
+
         // Fetchin the raw data
-        let res = await this.request<RawUserFollowing>(UserUrls.userFollowingUrl(userId, args.count, args.cursor)).then(res => res.data);
+        let res = await this.request<RawUserFollowing>(url).then(res => res.data);
 
         // Extracting data
         let data = UserExtractors.extractUserFollow(res);
@@ -163,10 +159,6 @@ export class UserService extends FetcherService {
      * @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.
-     * 
-     * @remarks
-     * 
-     * Cookies are required to use this method!
      */
     async getUserFollowers(userId: string, count?: number, cursor?: string): Promise<CursoredData<User>> {
         // If user is not authenticated, abort
@@ -177,8 +169,11 @@ export class UserService extends FetcherService {
         // Objectifying parameters
         let args: UserListArgs = new UserListArgs(count, cursor);
 
+        // Preparing the URL
+        const url: string = new Url(ResourceType.USER_FOLLOWERS, { id: userId, count: args.count, cursor: args.cursor }).toString();
+
         // Fetching the raw data
-        let res = await this.request<RawUserFollowers>(UserUrls.userFollowersUrl(userId, args.count, args.cursor)).then(res => res.data);
+        let res = await this.request<RawUserFollowers>(url).then(res => res.data);
 
         // Extracting data
         let data = UserExtractors.extractUserFollow(res);
@@ -200,10 +195,6 @@ export class UserService extends FetcherService {
      * @returns The list of tweets liked by the target user.
      * 
      * @throws {@link AuthenticationErrors.NotAuthenticated} error, if no cookies have been provided.
-     * 
-     * @remarks
-     * 
-     * Cookies are required to use this method!
      */
     async getUserLikes(userId: string, count?: number, cursor?: string): Promise<CursoredData<Tweet>> {
         // If user is not authenticated, abort
@@ -214,8 +205,11 @@ export class UserService extends FetcherService {
         // Objectifying parameters
         let args: UserListArgs = new UserListArgs(count, cursor);
 
+        // Preparing the URL
+        const url: string = new Url(ResourceType.USER_LIKES, { id: userId, count: args.count, cursor: args.cursor }).toString();
+
         // Fetching the raw data
-        let res = await this.request<RawUserLikes>(UserUrls.userLikesUrl(userId, args.count, args.cursor)).then(res => res.data);
+        let res = await this.request<RawUserLikes>(url).then(res => res.data);
 
         // Extracting data
         let data = UserExtractors.extractUserLikes(res);

package/src/services/helper/Parser.ts

@@ -7,7 +7,7 @@ import { ITweetFilter } from '../../types/Args';
  */
 export function isJSONEmpty(data: any): boolean {
     // If the JSON has any keys, it's not empty
-    if(Object.keys(data).length == 0) {
+    if (Object.keys(data).length == 0) {
         return true;
     }
     // Else, it's empty
@@ -78,33 +78,12 @@ export function dataToList(data: any | any[]): any[] {
  */
 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;
-}
-
-/**
- * @param filter The tweet filter to use for getting filtered tweets
- * @returns The same tweet filter, in a URL query format string
- */
-export function toQueryString(filter: ITweetFilter): string {
-    // Concatenating the input filter arguments to a URL query formatted string
-    return [
-        filter.words ? filter.words.join(' ') : '',
-        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 => '@' + 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 ? ' -filter:links' : '');
 }