rettiwt-api 1.1.8 → 1.3.0

package/src/graphql/resolvers/UserResolver.ts

@@ -29,13 +29,13 @@ export default class UserResolver extends ResolverBase {
 
     /**
      * @returns The list of tweets made by the given user
-     * @param id The id of the user whose tweets are to be fetched
-     * @param count The number of tweets to fetch, must be >= 40
+     * @param userName The username of the user whose tweets are to be fetched
+     * @param count The number of tweets to fetch, must be >= 10
      * @param all Whether to fetch list of all tweets made by user
      * @param cursor The cursor to the batch of tweets to fetch
      * @param statusesCount The total number of tweets made by target user
      */
-    async resolveUserTweets(id: string, count: number, all: boolean, cursor: string, statusesCount: number): Promise<any> {
+    async resolveUserTweets(userName: string, count: number, all: boolean, cursor: string, statusesCount: number): Promise<any> {
         let likes: any[] = [];                                                      // To store the list of tweets
         let next: Cursor = new Cursor(cursor);                                      // To store cursor to next batch
         let total: number = 0;                                                      // To store the total number of tweets fetched
@@ -52,7 +52,7 @@ export default class UserResolver extends ResolverBase {
             this.batchSize = ((count - total) < this.batchSize) ? (count - total) : this.batchSize;
 
             // Getting the data
-            const res = await this.context.users.getUserTweets(id, this.batchSize, next.value).catch(error => {
+            const res = await this.context.tweets.getTweets({ fromUsers: [userName] }, this.batchSize, next.value).catch(error => {
                 throw this.getGraphQLError(error);
             });
 

package/src/graphql/types/UserTypes.ts

@@ -1,10 +1,10 @@
 // PACKAGE
 import { GraphQLBoolean, GraphQLObjectType, GraphQLString, GraphQLInt, GraphQLList, GraphQLUnionType, GraphQLType } from 'graphql';
+import { TweetFilter } from 'rettiwt-core';
 
 // TYPES
 import { Tweet, TweetList } from './TweetTypes'
 import { Cursor } from './Global';
-import { TweetFilter } from '../../models/args/TweetFilter';
 
 // RESOLVERS
 import UserResolver from '../resolvers/UserResolver';
@@ -113,7 +113,7 @@ export const User: GraphQLObjectType = new GraphQLObjectType({
                     defaultValue: ''
                 }
             },
-            resolve: (parent, args, context) => new UserResolver(context).resolveUserTweets(parent.id, args.count, args.all, args.cursor, parent.statusesCount)
+            resolve: (parent, args, context) => new UserResolver(context).resolveUserTweets(parent.userName, args.count, args.all, args.cursor, parent.statusesCount)
         }
     })
 });

package/src/index.ts

@@ -44,19 +44,21 @@ export * from './services/util/CacheService';
 export * from './services/util/FetcherService';
 
 // Exporting types
+export { ITweetFilter } from 'rettiwt-core';
 export * from './types/Args';
 export { IAuthCookie } from './types/Authentication';
 export * from './types/Rettiwt';
 export * from './types/Service';
 export * from './types/Tweet';
 export * from './types/User';
+export { IDataValidationError } from 'rettiwt-core';
 
 // Exporting models
-export * from './models/args/TweetFilter';
+export { TweetFilter } from 'rettiwt-core';
 export * from './models/args/TweetListArgs';
 export * from './models/args/UserListArgs';
-export * from './models/auth/AuthCookie';
+export { AuthCookie } from './models/auth/AuthCookie';
 export * from './models/data/CursoredData';
 export * from './models/data/Tweet';
 export * from './models/data/User';
-export * from './models/errors/DataValidationError';
+export { DataValidationError } from 'rettiwt-core';

package/src/models/args/TweetListArgs.ts

@@ -1,9 +1,9 @@
 // PACKAGES
 import { IsInt, IsString, IsOptional, Min, validateSync, Max, ValidateIf } from 'class-validator';
+import { DataValidationError } from 'rettiwt-core';
 
 // TYPES
 import { IListArgs } from '../../types/Args';
-import { DataValidationError } from '../errors/DataValidationError';
 
 /**
  * The arguments for fetching cursored list in TweetService.
@@ -20,7 +20,7 @@ export class TweetListArgs implements IListArgs {
     @IsOptional()
     @Max(100)
     @ValidateIf(ob => ob.cursor.length == 0)
-    @Min(10)    
+    @Min(10)
     count: number;
 
     /** The cursor to the batch of data to fetch. */

package/src/models/args/UserListArgs.ts

@@ -1,9 +1,9 @@
 // PACKAGES
 import { IsInt, IsString, IsOptional, Min, validateSync, Max, ValidateIf } from 'class-validator';
+import { DataValidationError } from 'rettiwt-core';
 
 // TYPES
 import { IListArgs } from '../../types/Args';
-import { DataValidationError } from '../errors/DataValidationError';
 
 /**
  * The arguments for fetching cursored list in TweetService.

package/src/models/data/Tweet.ts

@@ -1,6 +1,6 @@
 // TYPES
 import { ITweet, ITweetEntities } from '../../types/Tweet';
-import { Result as RawTweet, Entities2 as RawTweetEntities } from '../../types/raw/tweet/Tweet';
+import { ITweet as IRawTweet, IEntities as IRawTweetEntities } from 'rettiwt-core';
 
 // PARSERS
 import * as Parsers from '../../services/helper/Parser';
@@ -25,7 +25,7 @@ export class TweetEntities implements ITweetEntities {
     media: string[] = [];
 
     // MEMBER METHODS
-    constructor(entities: RawTweetEntities) {
+    constructor(entities: IRawTweetEntities) {
         // Extracting user mentions
         if (entities.user_mentions) {
             for (let user of entities.user_mentions) {
@@ -101,7 +101,7 @@ export class Tweet implements ITweet {
     /**
      * @param tweet The raw tweet data.
      */
-    constructor(tweet: RawTweet) {
+    constructor(tweet: IRawTweet) {
         this.id = tweet.rest_id;
         this.createdAt = tweet.legacy.created_at;
         this.tweetBy = tweet.legacy.user_id_str;

package/src/models/data/User.ts

@@ -1,6 +1,6 @@
 // TYPES
 import { IUser } from '../../types/User';
-import { Result as RawUser } from '../../types/raw/user/User';
+import { IUser as IRawUser } from 'rettiwt-core';
 
 /**
  * The details of a single user.
@@ -53,7 +53,7 @@ export class User implements IUser {
     /**
      * @param user The raw user data.
      */
-    constructor(user: RawUser) {
+    constructor(user: IRawUser) {
         this.id = user.rest_id;
         this.userName = user.legacy.screen_name;
         this.fullName = user.legacy.name;

package/src/services/data/TweetService.ts

@@ -1,3 +1,16 @@
+// PACKAGES
+import {
+    Url,
+    EResourceType,
+    ITweetSearchResponse,
+    ITweetDetailsResponse,
+    ITweetFavoritersResponse,
+    ITweetRetweetersResponse,
+    ITweet as IRawTweet,
+    IUser as IRawUser,
+    TweetFilter
+} from 'rettiwt-core';
+
 // SERVICES
 import { FetcherService } from "../util/FetcherService";
 import { AuthService } from "../auth/AuthService";
@@ -6,28 +19,14 @@ import { AuthService } from "../auth/AuthService";
 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 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';
-
 // ENUMS
 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
@@ -42,24 +41,29 @@ export class TweetService extends FetcherService {
 
     /**
      * @param filter The filter be used for searching the tweets.
-     * @param count The number of tweets to fetch, must be >= 10 and <= 20
+     * @param count The number of tweets to fetch, must be >= 10 (when no cursor is provided) and <= 20
      * @param cursor The cursor to the next batch of tweets. If blank, first batch is fetched.
      * 
      * @returns The list of tweets that match the given filter.
      * 
+     * @throws {@link Errors.AuthenticationErrors.NotAuthenticated} error, if no cookies have been provided.
      * @throws {@link Errors.ValidationErrors.InvalidCount} error, if an invalid count has been provided.
-     * 
-     * @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(EResourceType.TWEET_SEARCH, { filter: 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<ITweetSearchResponse>(url).then(res => res.data);
 
         // Extracting data
         let data = TweetExtractors.extractTweets(res);
@@ -68,7 +72,7 @@ export class TweetService extends FetcherService {
         this.cacheData(data);
 
         // Parsing data
-        let tweets = data.required.map((item: TweetData) => new Tweet(item));
+        let tweets = data.required.map((item: IRawTweet) => new Tweet(item));
 
         // Sorting the tweets by date, from recent to oldest
         tweets.sort((a, b) => new Date(b.createdAt).valueOf() - new Date(a.createdAt).valueOf());
@@ -81,13 +85,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 +102,11 @@ export class TweetService extends FetcherService {
             return cachedData;
         }
 
+        // Preparing the URL
+        const url: string = new Url(EResourceType.TWEET_DETAILS, { id: id }).toString();
+
         // Fetching the raw data
-        let res = await this.request<RawTweet>(TweetUrls.tweetDetailsUrl(id), false).then(res => res.data);
+        let res = await this.request<ITweetDetailsResponse>(url).then(res => res.data);
 
         // Extracting data
         let data = TweetExtractors.extractTweet(res, id);
@@ -121,10 +130,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 +140,11 @@ export class TweetService extends FetcherService {
         // Objectifying parameters
         let args: TweetListArgs = new TweetListArgs(count, cursor);
 
+        // Preparing the URL
+        const url: string = new Url(EResourceType.TWEET_FAVORITERS, { id: tweetId, count: args.count, cursor: args.cursor }).toString();
+
         // Fetching the raw data
-        let res = await this.request<RawLikers>(TweetUrls.tweetLikesUrl(tweetId, args.count, args.cursor)).then(res => res.data);
+        let res = await this.request<ITweetFavoritersResponse>(url).then(res => res.data);
 
         // Extracting data
         let data = TweetExtractors.extractTweetLikers(res);
@@ -145,7 +153,7 @@ export class TweetService extends FetcherService {
         this.cacheData(data);
 
         // Parsing data
-        let users = data.required.map((item: UserData) => new User(item));
+        let users = data.required.map((item: IRawUser) => new User(item));
 
         return new CursoredData<User>(users, data.cursor);
     }
@@ -160,10 +168,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 +178,11 @@ export class TweetService extends FetcherService {
         // Objectifying parameters
         let args: TweetListArgs = new TweetListArgs(count, cursor);
 
+        // Preparing the URL
+        const url: string = new Url(EResourceType.TWEET_RETWEETERS, { id: tweetId, count: args.count, cursor: args.cursor }).toString();
+
         // Fetching the raw data
-        let res = await this.request<RawRetweeters>(TweetUrls.tweetRetweetUrl(tweetId, args.count, args.cursor)).then(res => res.data);
+        let res = await this.request<ITweetRetweetersResponse>(url).then(res => res.data);
 
         // Extracting data
         let data = TweetExtractors.extractTweetRetweeters(res);
@@ -184,42 +191,8 @@ export class TweetService extends FetcherService {
         this.cacheData(data);
 
         // Parsing data
-        let users = data.required.map((item: UserData) => new User(item));
+        let users = data.required.map((item: IRawUser) => new User(item));
 
         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

@@ -1,3 +1,15 @@
+// PACKAGES
+import {
+    Url,
+    EResourceType,
+    IUserDetailsResponse,
+    IUserFollowersResponse,
+    IUserFollowingResponse,
+    IUserLikesResponse,
+    ITweet as IRawTweet,
+    IUser as IRawUser
+} from 'rettiwt-core';
+
 // SERVICES
 import { FetcherService } from '../util/FetcherService';
 import { AuthService } from '../auth/AuthService';
@@ -9,21 +21,13 @@ 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';
 
 // ENUMS
 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,44 +45,43 @@ 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> {
-        let res: RawUser;
+        // If user is not authenticated, abort
+        if (!this.isAuthenticated) {
+            throw new Error(AuthenticationErrors.NotAuthenticated);
+        }
 
-        // 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);
+        let res: IUserDetailsResponse;
+
+        // Getting data from cache
+        let cachedData = await this.readData(id);
+
+        // If data exists in cache
+        if (cachedData) {
+            return cachedData;
         }
-        // If id is a numeric string => id is supplied
+        // Else, fetch the data from Twitter instead
         else {
-            // Getting data from cache
-            let cachedData = await this.readData(id);
-
-            // If data exists in cache
-            if (cachedData) {
-                return cachedData;
-            }
+            // Preparing the URL
+            const url: string = new Url(EResourceType.USER_DETAILS, { id: id }).toString();
 
             // Fetching the raw data
-            res = await this.request<RawUser>(UserUrls.userDetailsByIdUrl(id), false).then(res => res.data);
-        }
+            res = await this.request<IUserDetailsResponse>(url).then(res => res.data);
 
-        // Extracting data
-        let data = UserExtractors.extractUserDetails(res);
+            // Extracting data
+            let data = UserExtractors.extractUserDetails(res);
 
-        // Caching data
-        this.cacheData(data);
+            // Caching data
+            this.cacheData(data);
 
-        // Parsing data
-        let user = new User(data.required[0]);
+            // Parsing data
+            let user = new User(data.required[0]);
 
-        return user;
+            return user;
+        }
     }
 
     /**
@@ -88,30 +91,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);
-
-        // Extracting data
-        let data = UserExtractors.extractUserTweets(res);
-
-        // Caching data
-        this.cacheData(data);
-
-        // Parsing data
-        let tweets = data.required.map((item: TweetData) => new Tweet(item));
+        // Getting the username of the target user
+        const userName: string = (await this.getUserDetails(userId)).userName;
 
-        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 +117,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 +127,11 @@ export class UserService extends FetcherService {
         // Objectifying parameters
         let args: UserListArgs = new UserListArgs(count, cursor);
 
+        // Preparing the URL
+        const url: string = new Url(EResourceType.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<IUserFollowingResponse>(url).then(res => res.data);
 
         // Extracting data
         let data = UserExtractors.extractUserFollow(res);
@@ -148,7 +140,7 @@ export class UserService extends FetcherService {
         this.cacheData(data);
 
         // Parsing data
-        let users = data.required.map((item: UserData) => new User(item));
+        let users = data.required.map((item: IRawUser) => new User(item));
 
         return new CursoredData<User>(users, data.cursor);
     }
@@ -163,10 +155,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 +165,11 @@ export class UserService extends FetcherService {
         // Objectifying parameters
         let args: UserListArgs = new UserListArgs(count, cursor);
 
+        // Preparing the URL
+        const url: string = new Url(EResourceType.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<IUserFollowersResponse>(url).then(res => res.data);
 
         // Extracting data
         let data = UserExtractors.extractUserFollow(res);
@@ -187,7 +178,7 @@ export class UserService extends FetcherService {
         this.cacheData(data);
 
         // Parsing data
-        let users = data.required.map((item: UserData) => new User(item));
+        let users = data.required.map((item: IRawUser) => new User(item));
 
         return new CursoredData<User>(users, data.cursor);
     }
@@ -200,10 +191,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 +201,11 @@ export class UserService extends FetcherService {
         // Objectifying parameters
         let args: UserListArgs = new UserListArgs(count, cursor);
 
+        // Preparing the URL
+        const url: string = new Url(EResourceType.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<IUserLikesResponse>(url).then(res => res.data);
 
         // Extracting data
         let data = UserExtractors.extractUserLikes(res);
@@ -224,7 +214,7 @@ export class UserService extends FetcherService {
         this.cacheData(data);
 
         // Parsing data
-        let tweets = data.required.map((item: TweetData) => new Tweet(item));
+        let tweets = data.required.map((item: IRawTweet) => new Tweet(item));
 
         return new CursoredData<Tweet>(tweets, data.cursor);
     }