rettiwt-api 1.1.8 → 1.2.0

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' : '');
 }

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

@@ -1,10 +1,10 @@
 // TYPES
 import { IDataExtract } from '../../../types/Resolvers';
 import { DataErrors } from '../../../enums/Errors';
-import RawTweet from '../../../types/raw/tweet/Tweet';
-import RawTweets from '../../../types/raw/tweet/Tweets';
-import RawRetweeters from '../../../types/raw/tweet/Retweeters';
-import RawLikers from '../../../types/raw/tweet/Favouriters';
+import RawTweet from '../../../twitter/types/tweet/Tweet';
+import RawTweets from '../../../twitter/types/tweet/Tweets';
+import RawRetweeters from '../../../twitter/types/tweet/Retweeters';
+import RawLikers from '../../../twitter/types/tweet/Favouriters';
 
 // PARSERS
 import * as Parsers from '../Parser';

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

@@ -1,11 +1,11 @@
 // TYPES
 import { IDataExtract } from '../../../types/Resolvers'
 import { DataErrors } from '../../../enums/Errors';
-import RawUser 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 RawUser from '../../../twitter/types/user/User';
+import RawUserTweets from '../../../twitter/types/user/Tweets';
+import RawUserFollowers from '../../../twitter/types/user/Followers';
+import RawUserFollowing from '../../../twitter/types/user/Following';
+import RawUserLikes from '../../../twitter/types/user/Likes';
 
 // PARSERS
 import * as Parsers from '../Parser';

package/src/services/util/FetcherService.ts

@@ -10,8 +10,8 @@ import { Tweet } from '../../models/data/Tweet';
 import { User } from '../../models/data/User';
 
 // TYPES
-import { Result as RawUser } from '../../types/raw/user/User';
-import { Result as RawTweet } from '../../types/raw/tweet/Tweet';
+import { Result as RawUser } from '../../twitter/types/user/User';
+import { Result as RawTweet } from '../../twitter/types/tweet/Tweet';
 
 // ENUMS
 import { HttpStatus } from "../../enums/HTTP";
@@ -37,7 +37,7 @@ export enum HttpMethods {
 export class FetcherService {
     // MEMBER DATA
     /** The authentication service instance. */
-    private auth: AuthService;
+    protected auth: AuthService;
 
     /** The caching service instance. */
     private cache: CacheService;
@@ -71,7 +71,7 @@ export class FetcherService {
         if (res.statusCode != 200 && res.statusCode in HttpStatus) {
             throw new Error(HttpStatus[res.statusCode])
         }
-        
+
         return res;
     }
 

package/src/twitter/Url.ts

@@ -0,0 +1,37 @@
+// ENUMS
+import { ResourceType } from "./enums/Resources";
+
+// PAYLOADS
+import { Args } from './payloads/Args';
+import { Query } from './params/Query';
+
+/**
+ * A class that deals with generation of URLs to various resources on Twitter.
+ */
+export class Url {
+    /** The base Twitter API url. */
+    private baseUrl: string = 'https://api.twitter.com';
+
+    /** The fully initialized target resource URL. */
+    public fullUrl: string;
+
+    /**
+     * Initializes a URL for fetching the specified resource, using the given arguments.
+     * 
+     * @param resourceType The type of resource to fetch.
+     * @param args Any additional arguments.
+     */
+    constructor(resourceType: ResourceType, args: Args) {
+        /**
+         * Initializing full URL along with additional URL parameters.
+         */
+        this.fullUrl = `${this.baseUrl}${resourceType}?${new Query(resourceType, args).toString()}`;
+    }
+
+    /**
+     * @returns The string representation of thi Url.
+     */
+    public toString(): string {
+        return this.fullUrl;
+    }
+}

package/src/twitter/enums/Resources.ts

@@ -0,0 +1,15 @@
+/**
+ * The different types of resources that can be fetched.
+ */
+export enum ResourceType {
+    'TWEETS' = '/2/search/adaptive.json',
+    'TWEET_DETAILS' = '/graphql/lXI2kaM2hgmbf7h42kpxuA/TweetDetail',
+    'TWEET_LIKES' = '/graphql/56ZwFC3Vui31fF8IYX8EGA/Favoriters',
+    'TWEET_RETWEETS' = '/graphql/Wd7DVeLqMj_JQiTL0tjJwQ/Retweeters',
+    'USER_DETAILS' = '/graphql/hVhfo_TquFTmgL7gYwf91Q/UserByScreenName',
+    'USER_DETAILS_BY_ID' = '/graphql/mi_IjXgFyr41N9zkszPz9w/UserByRestId',
+    'USER_TWEETS' = '/graphql/xxLjoOBBPpYBHbBTI-hevQ/UserTweetsAndReplies',
+    'USER_FOLLOWING' = '/graphql/mSnjZc5CTm2Z5Lu_i4XsPQ/Following',
+    'USER_FOLLOWERS' = '/graphql/nwlAnaw7oKXcVLi91ehy7Q/Followers',
+    'USER_LIKES' = '/graphql/gP4ZKghLd4tpILgS6VudAQ/Likes'
+};

package/src/twitter/params/Query.ts

@@ -0,0 +1,100 @@
+// PAYLOADS
+import { Variables } from '../payloads/Variables';
+import { Features } from '../payloads/Features';
+import { Args } from '../payloads/Args';
+
+// TYPES
+import { IQuery } from '../types/request/Query';
+
+// ENUMS
+import { ResourceType } from '../enums/Resources';
+
+/**
+ * The URL query parameters that must be sent while making requests to Twitter API.
+ */
+export class Query implements IQuery {
+    cards_platform?: string;
+    count?: number;
+    cursor?: string;
+    ext?: string;
+    include_blocked_by?: number;
+    include_blocking?: number;
+    include_can_dm?: number;
+    include_can_media_tag?: number;
+    include_cards?: number;
+    include_entities?: boolean = true;
+    include_ext_alt_text?: boolean;
+    include_ext_collab_control?: boolean;
+    include_ext_edit_control?: boolean;
+    include_ext_has_nft_avatar?: number;
+    include_ext_is_blue_verified?: number;
+    include_ext_limited_action_results?: boolean;
+    include_ext_media_availability?: boolean;
+    include_ext_media_color?: boolean;
+    include_ext_sensitive_media_warning?: boolean;
+    include_ext_trusted_friends_metadata?: boolean;
+    include_ext_verified_type?: number;
+    include_ext_views?: boolean;
+    include_followed_by?: number;
+    include_mute_edge?: number;
+    include_profile_interstitial_type?: number;
+    include_quote_count?: boolean = true;
+    include_reply_count?: number = 1;
+    include_user_entities?: boolean = true;
+    include_want_retweets?: number = 1;
+    pc?: number;
+    q?: string;
+    query_source?: string;
+    send_error_codes?: boolean;
+    simple_quoted_tweet?: boolean;
+    skip_status?: number;
+    spelling_corrections?: number;
+    tweet_mode?: string = 'extended';
+    tweet_search_mode?: string = 'live';
+
+    /**
+     * Variables for fetching data.
+     */
+    variables?: string;
+
+    /**
+     * Additional data features that must be fetched.
+     */
+    features?: string;
+
+    /**
+     * Initializes the URL parameters.
+     * 
+     * @param resourceType The type of resource requested.
+     * @param args Additional user-defined arguments to be sent in the request.
+     */
+    constructor(resourceType: ResourceType, args: Args) {
+        /**
+         * Only the endpoint for fetching tweets (using advanced search) requires the parameters defined in this class.
+         * All other endpoints required only 'variables' and 'features' fields.
+         */
+        if (resourceType == ResourceType.TWEETS) {
+            this.q = encodeURIComponent(args.query ?? '');
+            this.count = args.count;
+            this.cursor = args.cursor;
+        }
+        else {
+            this.variables = new Variables(resourceType, args).toString();
+            this.features = new Features().toString();
+        }
+    }
+
+    /**
+     * Converts this object to it's string representation.
+     * 
+     * @returns 'this' object's string representation;
+     */
+    toString(): string {
+        /**
+         * This first filters out all the empty paramters.
+         * Then it formats each parameter key value pair as 'key=value'.
+         * Then it joins the list of all formatted parameters using '&' as a separator.
+         */
+        return Object.entries(this).filter(([key, value]) => value).map(([key, value]) => `${key}=${value}`).join('&');
+    }
+}

package/src/twitter/payloads/Args.ts

@@ -0,0 +1,21 @@
+// TYPES
+import { IArgs } from '../types/request/Query';
+
+/**
+ * The arguments for fetching cursored list.
+ * 
+ * @public
+ */
+export class Args implements IArgs {
+    /** The query string that may be used to filter data. */
+    query?: string;
+
+    /** The rest id of the data item to be requested. */
+    id?: string;
+
+    /** The number of data items to fetch. */
+    count?: number;
+
+    /** The cursor to the batch of data to fetch. */
+    cursor?: string;
+};