rettiwt-api 1.1.1 → 1.1.5

package/src/services/data/TweetService.ts

@@ -1,17 +1,23 @@
 // SERVICES
-import { FetcherService } from "../FetcherService";
-import { AuthService } from "../AuthService";
+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 { TweetFilter } from "../../models/args/TweetFilter";
+import { CursoredData } from '../../models/data/CursoredData';
 
 // TYPES
-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';
+
+// ENUMS
+import { AuthenticationErrors } from '../../enums/Errors';
 
 // URLS
 import * as TweetUrls from '../helper/urls/Tweets';
@@ -19,10 +25,6 @@ import * as TweetUrls from '../helper/urls/Tweets';
 // EXTRACTORS
 import * as TweetExtractors from "../helper/extractors/Tweets";
 
-// DESERIALIZERS
-import * as UserDeserializers from '../helper/deserializers/Users';
-import * as TweetDeserializers from '../helper/deserializers/Tweets';
-
 // PARSERS
 import { toQueryString } from '../helper/Parser';
 
@@ -31,7 +33,6 @@ import { toQueryString } from '../helper/Parser';
  * @public
  */
 export class TweetService extends FetcherService {
-    // MEMBER METHODS
     /**
      * @param auth The AuthService instance to use for authentication.
      */
@@ -41,19 +42,24 @@ export class TweetService extends FetcherService {
 
     /**
      * @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 >= 10 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.
-     * @remarks count must be >= 1 and <= 100.
+     * 
+     * @throws {@link Errors.ValidationErrors.InvalidCount} error, if an invalid count has been provided.
+     * 
+     * @remarks
+     * 
+     * If cookies have been provided, then authenticated requests are made. Else, guest requests are made.
      */
-    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);
-        }
+    async getTweets(query: TweetFilter, count?: number, cursor?: string): Promise<CursoredData<Tweet>> {
+        // Objectifying parameters
+        let filter: TweetFilter = new TweetFilter(query);
+        let args: TweetListArgs = new TweetListArgs(count, cursor);
 
         // Getting the raw data
-        let res = await this.request<RawTweets>(TweetUrls.tweetsUrl(toQueryString(filter), count, cursor), false).then(res => res.data);
+        let res = await this.request<RawTweets>(TweetUrls.tweetsUrl(toQueryString(filter), args.count, args.cursor), this.isAuthenticated).then(res => res.data);
 
         // Extracting data
         let data = TweetExtractors.extractTweets(res);
@@ -62,21 +68,28 @@ export class TweetService extends FetcherService {
         this.cacheData(data);
 
         // Parsing data
-        let tweets = data.required.map((item: TweetData) => TweetDeserializers.toTweet(item));
+        let tweets = data.required.map((item: TweetData) => new Tweet(item));
 
-        return {
-            list: tweets,
-            next: { value: data.cursor }
-        };
+        // 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 tweetId The rest id of the target tweet.
+     * @param id The id of the target tweet.
+     * 
      * @returns The details of a single tweet with the given tweet id.
+     * 
+     * @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 getTweetById(tweetId: string): Promise<Tweet> {
+    async getTweetDetails(id: string): Promise<Tweet> {
         // Getting data from cache
-        let cachedData = await this.readData(tweetId);
+        let cachedData = await this.readData(id);
 
         // If data exists in cache
         if (cachedData) {
@@ -84,40 +97,46 @@ export class TweetService extends FetcherService {
         }
         
         // Fetching the raw data
-        let res = await this.request<RawTweet>(TweetUrls.tweetDetailsUrl(tweetId), false).then(res => res.data);
+        let res = await this.request<RawTweet>(TweetUrls.tweetDetailsUrl(id), false).then(res => res.data);
 
         // Extracting data
-        let data = TweetExtractors.extractTweet(res, tweetId);
+        let data = TweetExtractors.extractTweet(res, id);
 
         // Caching data
         this.cacheData(data);
 
         // Parsing data
-        let tweet = TweetDeserializers.toTweet(data.required[0]);
+        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.
+     * @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.
-     * @remarks count must be >= 10 (when no cursor is provided) and <= 100.
+     * 
+     * @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>> {
+    async getTweetLikers(tweetId: string, count?: number, cursor?: string): Promise<CursoredData<User>> {
         // If user is not authenticated, abort
         if(!this.isAuthenticated) {
-            throw new Error(Errors.AuthenticationErrors.NotAuthenticated);
+            throw new Error(AuthenticationErrors.NotAuthenticated);
         }
 
-        // If invalid count provided
-        if (count < 10 && !cursor) {
-            throw new Error(Errors.ValidationErrors.InvalidCount);
-        }
+        // Objectifying parameters
+        let args: TweetListArgs = new TweetListArgs(count, cursor);
         
         // Fetching the raw data
-        let res = await this.request<RawLikers>(TweetUrls.tweetLikesUrl(tweetId, count, cursor)).then(res => res.data);
+        let res = await this.request<RawLikers>(TweetUrls.tweetLikesUrl(tweetId, args.count, args.cursor)).then(res => res.data);
 
         // Extracting data
         let data = TweetExtractors.extractTweetLikers(res);
@@ -126,34 +145,37 @@ export class TweetService extends FetcherService {
         this.cacheData(data);
 
         // Parsing data
-        let users = data.required.map((item: UserData) => UserDeserializers.toUser(item));
+        let users = data.required.map((item: UserData) => new User(item));
 
-        return {
-            list: users,
-            next: { value: data.cursor }
-        };
+        return new CursoredData<User>(users, data.cursor);
     }
 
     /**
      * @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.
+     * 
      * @returns The list of users who retweeted the given tweet.
-     * @remarks count must be >= 10 (when no cursor is provided) and <= 100.
+     * 
+     * @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>> {
+    async getTweetRetweeters(tweetId: string, count?: number, cursor?: string): Promise<CursoredData<User>> {
         // If user is not authenticated, abort
         if(!this.isAuthenticated) {
-            throw new Error(Errors.AuthenticationErrors.NotAuthenticated);
+            throw new Error(AuthenticationErrors.NotAuthenticated);
         }
 
-        // If invalid count provided
-        if (count < 10 && !cursor) {
-            throw new Error(Errors.ValidationErrors.InvalidCount);
-        }
+        // Objectifying parameters
+        let args: TweetListArgs = new TweetListArgs(count, cursor);
 
         // Fetching the raw data
-        let res = await this.request<RawRetweeters>(TweetUrls.tweetRetweetUrl(tweetId, count, cursor)).then(res => res.data);
+        let res = await this.request<RawRetweeters>(TweetUrls.tweetRetweetUrl(tweetId, args.count, args.cursor)).then(res => res.data);
 
         // Extracting data
         let data = TweetExtractors.extractTweetRetweeters(res);
@@ -162,12 +184,9 @@ export class TweetService extends FetcherService {
         this.cacheData(data);
 
         // Parsing data
-        let users = data.required.map((item: UserData) => UserDeserializers.toUser(item));
+        let users = data.required.map((item: UserData) => new User(item));
 
-        return {
-            list: users,
-            next: { value: data.cursor }
-        };
+        return new CursoredData<User>(users, data.cursor);
     }
 
     /**

package/src/services/data/UserService.ts

@@ -1,17 +1,22 @@
 // SERVICES
-import { FetcherService } from '../FetcherService';
-import { AuthService } from '../AuthService';
+import { FetcherService } from '../util/FetcherService';
+import { AuthService } from '../auth/AuthService';
+
+// MODELS
+import { User } from '../../models/data/User';
+import { UserListArgs } from '../../models/args/UserListArgs';
+import { Tweet } from '../../models/data/Tweet';
 
 // TYPES
-import { User } from '../../types/data/User';
-import { Tweet } from '../../types/data/Tweet';
-import { CursoredData } from '../../types/data/Service';
+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 RawUserFollowers from '../../types/raw/user/Followers';
 import RawUserFollowing from '../../types/raw/user/Following';
 import RawUserLikes from '../../types/raw/user/Likes';
-import * as Errors from '../../types/data/Errors';
+
+// ENUMS
+import { AuthenticationErrors } from '../../enums/Errors';
 
 // URLS
 import * as UserUrls from '../helper/urls/Users';
@@ -19,15 +24,10 @@ import * as UserUrls from '../helper/urls/Users';
 // EXTRACTORS
 import * as UserExtractors from '../helper/extractors/Users';
 
-// DESERIALIZERS
-import * as UserDeserializers from '../helper/deserializers/Users';
-import * as TweetDeserializers from '../helper/deserializers/Tweets';
-
 /**
  * Handles fetching of data related to user account
  */
 export class UserService extends FetcherService {
-    // MEMBER METHODS
     /**
      * @param auth The AuthService instance to use for authentication.
      */
@@ -36,40 +36,37 @@ export class UserService extends FetcherService {
     }
 
     /**
-     * @param screenName The screen name of the target user.
+     * @param id The id/username of the target user.
+     * 
      * @returns The details of the given user.
+     * 
+     * @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(screenName: string): Promise<User> {
-        // Fetching the raw data
-        let res: RawUser = await this.request<RawUser>(UserUrls.userDetailsUrl(screenName), false).then(res => res.data);
-        
-        // Extracting data
-        let data = UserExtractors.extractUserDetails(res);
-
-        // Caching data
-        this.cacheData(data);
+    async getUserDetails(id: string): Promise<User> {
+        let res: RawUser;
 
-        // Parsing data
-        let user = UserDeserializers.toUser(data.required[0]);
-            
-        return user;
-    }
-
-    /**
-     * @param restId The screen name of the target user.
-     * @returns The details of the user with given rest id.
-     */
-    async getUserDetailsById(restId: string): Promise<User> {
-        // Getting data from cache
-        let cachedData = await this.readData(restId);
-
-        // If data exists in cache
-        if(cachedData) {
-            return cachedData;
+        // If id is not a numeric string => username is supplied
+        if (isNaN(Number(id))) {
+            // Fetching the raw data
+            res = await this.request<RawUser>(UserUrls.userDetailsUrl(id), false).then(res => res.data);
+        }
+        // If id is a numeric string => id is supplied
+        else {
+            // Getting data from cache
+            let cachedData = await this.readData(id);
+
+            // If data exists in cache
+            if (cachedData) {
+                return cachedData;
+            }
+
+            // Fetching the raw data
+            res = await this.request<RawUser>(UserUrls.userDetailsByIdUrl(id), false).then(res => res.data);
         }
-        
-        // Fetchin the raw data
-        let res = await this.request<RawUser>(UserUrls.userDetailsByIdUrl(restId), false).then(res => res.data);
 
         // Extracting data
         let data = UserExtractors.extractUserDetails(res);
@@ -78,32 +75,38 @@ export class UserService extends FetcherService {
         this.cacheData(data);
 
         // Parsing data
-        let user = UserDeserializers.toUser(data.required[0]);
-            
+        let user = new User(data.required[0]);
+
         return user;
     }
 
     /**
      * @param userId The rest id of the target user.
-     * @param count The number of following to fetch.
+     * @param count The number of following to fetch, must be >= 40 (when no cursor is provided) and <=100.
      * @param cursor The cursor to next batch. If blank, first batch is fetched.
+     * 
      * @returns The list of users followed by the target user.
-     * @remarks count must be >= 40 (when no cursor is provided) and <=100.
+     * 
+     * @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>> {
+    async getUserFollowing(userId: string, count?: number, cursor?: string): Promise<CursoredData<User>> {
         // If user is not authenticated, abort
-        if(!this.isAuthenticated) {
-            throw new Error(Errors.AuthenticationErrors.NotAuthenticated);
+        if (!this.isAuthenticated) {
+            throw new Error(AuthenticationErrors.NotAuthenticated);
         }
 
-        // If invalid count provided
-        if (count < 40 && !cursor) {
-            throw new Error(Errors.ValidationErrors.InvalidCount);
-        }
+        // Objectifying parameters
+        let args: UserListArgs = new UserListArgs(count, cursor);
 
         // Fetchin the raw data
-        let res = await this.request<RawUserFollowing>(UserUrls.userFollowingUrl(userId, count, cursor)).then(res => res.data);
-        
+        let res = await this.request<RawUserFollowing>(UserUrls.userFollowingUrl(userId, args.count, args.cursor)).then(res => res.data);
+
         // Extracting data
         let data = UserExtractors.extractUserFollow(res);
 
@@ -111,35 +114,38 @@ export class UserService extends FetcherService {
         this.cacheData(data);
 
         // Parsing data
-        let users = data.required.map((item: UserData) => UserDeserializers.toUser(item));
+        let users = data.required.map((item: UserData) => new User(item));
 
-        return {
-            list: users,
-            next: { value: data.cursor }
-        };
+        return new CursoredData<User>(users, data.cursor);
     }
 
     /**
      * @param userId The rest id of the target user.
-     * @param count The number of followers to fetch.
+     * @param count The number of followers to fetch, must be >= 40 (when no cursor is provided) and <=100.
      * @param cursor The cursor to next batch. If blank, first batch is fetched.
+     * 
      * @returns The list of users following the target user.
-     * @remarks count must be >= 40 (when no cursor is provided) and <=100.
+     * 
+     * @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>> {
+    async getUserFollowers(userId: string, count?: number, cursor?: string): Promise<CursoredData<User>> {
         // If user is not authenticated, abort
         if (!this.isAuthenticated) {
-            throw new Error(Errors.AuthenticationErrors.NotAuthenticated);
+            throw new Error(AuthenticationErrors.NotAuthenticated);
         }
 
-        // If invalid count provided
-        if (count < 40 && !cursor) {
-            throw new Error(Errors.ValidationErrors.InvalidCount);
-        }
+        // Objectifying parameters
+        let args: UserListArgs = new UserListArgs(count, cursor);
 
         // Fetching the raw data
-        let res = await this.request<RawUserFollowers>(UserUrls.userFollowersUrl(userId, count, cursor)).then(res => res.data);
-        
+        let res = await this.request<RawUserFollowers>(UserUrls.userFollowersUrl(userId, args.count, args.cursor)).then(res => res.data);
+
         // Extracting data
         let data = UserExtractors.extractUserFollow(res);
 
@@ -147,35 +153,36 @@ export class UserService extends FetcherService {
         this.cacheData(data);
 
         // Parsing data
-        let users = data.required.map((item: UserData) => UserDeserializers.toUser(item));
+        let users = data.required.map((item: UserData) => new User(item));
 
-        return {
-            list: users,
-            next: { value: data.cursor }
-        };
+        return new CursoredData<User>(users, data.cursor);
     }
 
     /**
      * @param userId The rest id of the target user.
      * @param count The number of likes to fetch.
-     * @param cursor The cursor to next batch. If blank, first batch is fetched.
+     * @param cursor The cursor to next batch. If blank, first batch is fetched, must be >= 40 (when no cursor is provided) and <=100.
+     * 
      * @returns The list of tweets liked by the target user.
-     * @remarks count must be >= 40 (when no cursor is provided) and <= 100.
+     * 
+     * @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>> {
+    async getUserLikes(userId: string, count?: number, cursor?: string): Promise<CursoredData<Tweet>> {
         // If user is not authenticated, abort
         if (!this.isAuthenticated) {
-            throw new Error(Errors.AuthenticationErrors.NotAuthenticated);
+            throw new Error(AuthenticationErrors.NotAuthenticated);
         }
 
-        // If invalid count provided
-        if (count < 40 && !cursor) {
-            throw new Error(Errors.ValidationErrors.InvalidCount);
-        }
+        // Objectifying parameters
+        let args: UserListArgs = new UserListArgs(count, cursor);
 
         // Fetching the raw data
-        let res = await this.request<RawUserLikes>(UserUrls.userLikesUrl(userId, count, cursor)).then(res => res.data);
-        
+        let res = await this.request<RawUserLikes>(UserUrls.userLikesUrl(userId, args.count, args.cursor)).then(res => res.data);
+
         // Extracting data
         let data = UserExtractors.extractUserLikes(res);
 
@@ -183,11 +190,8 @@ export class UserService extends FetcherService {
         this.cacheData(data);
 
         // Parsing data
-        let tweets = data.required.map((item: TweetData) => TweetDeserializers.toTweet(item));
+        let tweets = data.required.map((item: TweetData) => new Tweet(item));
 
-        return {
-            list: tweets,
-            next: { value: data.cursor }
-        };
+        return new CursoredData<Tweet>(tweets, data.cursor);
     }
 };

package/src/services/helper/Headers.ts

@@ -1,5 +1,5 @@
 // TYPES
-import { GuestCredentials, AuthCredentials } from '../../types/Authentication';
+import { IGuestCredentials, IAuthCredentials } from '../../types/Authentication';
 
 /**
  * @param authToken The authentication token received from Twitter
@@ -7,7 +7,7 @@ import { GuestCredentials, AuthCredentials } from '../../types/Authentication';
  * @param cookie The cookie associated with the logged in account
  * @returns The header required for making authorized HTTP requests
  */
-export function authorizedHeader(authCred: AuthCredentials): any {
+export function authorizedHeader(authCred: IAuthCredentials): any {
     return [
         `sec-ch-ua: "Not_A Brand";v="99", "Microsoft Edge";v="109", "Chromium";v="109"`,
         `x-twitter-client-language: en`,
@@ -28,7 +28,7 @@ export function authorizedHeader(authCred: AuthCredentials): any {
  * @param guestCred The guest credentials to use
  * @returns The header requred for making guest HTTP requests
  */
-export function guestHeader(guestCred: GuestCredentials): any {
+export function guestHeader(guestCred: IGuestCredentials): any {
     return [
         'Accept: */*',
         `authorization: ${guestCred.authToken}`,
@@ -42,7 +42,7 @@ export function guestHeader(guestCred: GuestCredentials): any {
  * @param cookie The cookie to be used
  * @returns The header for making HTTP request for logging in
  */
-export function loginHeader(guestCred: GuestCredentials, cookie: string): any {
+export function loginHeader(guestCred: IGuestCredentials, cookie: string): any {
     return [ 
         `sec-ch-ua: "Not_A Brand";v="99", "Microsoft Edge";v="109", "Chromium";v="109"`, 
         `x-twitter-client-language: en`, 

package/src/services/helper/Parser.ts

@@ -1,5 +1,5 @@
 // TYPES
-import { TweetFilter } from '../../types/data/Tweet';
+import { ITweetFilter } from '../../types/Args';
 
 /**
  * @returns Whether the given json object is empty or not
@@ -92,7 +92,7 @@ export function normalizeText(text: string): string {
  * @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: TweetFilter): string {
+export function toQueryString(filter: ITweetFilter): string {
     // Concatenating the input filter arguments to a URL query formatted string
     return [
         filter.words ? filter.words.join(' ') : '',

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

@@ -1,6 +1,6 @@
 // TYPES
-import { DataExtract } from '../../../types/Resolvers';
-import { DataErrors } from '../../../types/data/Errors';
+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';
@@ -13,7 +13,7 @@ import * as Parsers from '../Parser';
  * @returns The raw tweets data formatted and sorted into required and additional data
  * @param res The raw response received from TwitterAPI
  */
-export function extractTweets(res: RawTweets): DataExtract {
+export function extractTweets(res: RawTweets): IDataExtract {
     let required: any[] = [];                                               // To store the reqruied raw data
     let cursor: string = '';                                                // To store the cursor to next batch
     let users: any[] = [];                                                  // To store additional user data
@@ -63,7 +63,7 @@ export function extractTweets(res: RawTweets): DataExtract {
  * @param res The raw response received from TwitterAPI
  * @param tweetId The rest id of the tweet to fetch
  */
-export function extractTweet(res: RawTweet, tweetId: string): DataExtract {
+export function extractTweet(res: RawTweet, tweetId: string): IDataExtract {
     let required: any[] = [];                                               // To store the reqruied raw data
     let cursor: string = '';                                                // To store the cursor to next batch
     let users: any[] = [];                                                  // To store additional user data
@@ -112,7 +112,7 @@ export function extractTweet(res: RawTweet, tweetId: string): DataExtract {
  * @returns The raw tweet likers data formatted and sorted into required and additional data
  * @param res The raw response received from TwitterAPI
  */
-export function extractTweetLikers(res: RawLikers): DataExtract {
+export function extractTweetLikers(res: RawLikers): IDataExtract {
     let required: any[] = [];                                               // To store the reqruied raw data
     let cursor: string = '';                                                // To store the cursor to next batch
     let users: any[] = [];                                                  // To store additional user data
@@ -152,7 +152,7 @@ export function extractTweetLikers(res: RawLikers): DataExtract {
  * @returns The raw tweet retweeters data formatted and sorted into required and additional data
  * @param res The raw response received from TwitterAPI
  */
-export function extractTweetRetweeters(res: RawRetweeters): DataExtract {
+export function extractTweetRetweeters(res: RawRetweeters): IDataExtract {
     let required: any[] = [];                                               // To store the reqruied raw data
     let cursor: string = '';                                                // To store the cursor to next batch
     let users: any[] = [];                                                  // To store additional user data
@@ -193,7 +193,7 @@ export function extractTweetRetweeters(res: RawRetweeters): DataExtract {
  * @param res The raw response received from TwitterAPI
  * @param tweetId The id of the tweet whose replies must be extracted
  */
-export function extractTweetReplies(res: RawTweet, tweetId: string): DataExtract {
+export function extractTweetReplies(res: RawTweet, tweetId: string): IDataExtract {
     let required: any[] = [];                                               // To store the reqruied raw data
     let cursor: string = '';                                                // To store the cursor to next batch
     let users: any[] = [];                                                  // To store additional user data