rettiwt-api 1.0.6 → 1.0.8

package/src/services/data/TweetService.ts

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

package/src/services/data/UserService.ts

@@ -0,0 +1,187 @@
+// SERVICES
+import { FetcherService } from '../FetcherService';
+import { AuthService } from '../AuthService';
+
+// TYPES
+import { User } from '../../types/data/User';
+import { Tweet } from '../../types/data/Tweet';
+import { CursoredData } from '../../types/data/Service';
+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';
+
+// URLS
+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';
+
+/**
+ * A service that deals with fetching of data related to user account
+ */
+export class UserService extends FetcherService {
+    // MEMBER METHODS
+    constructor(auth: AuthService) {
+        super(auth);
+    }
+
+    /**
+     * @returns The details of the given user
+     * @param screenName The screen name of the target user.
+     */
+    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);
+
+        // Parsing data
+        let user = UserDeserializers.toUser(data.required[0]);
+            
+        return user;
+    }
+
+    /**
+     * @returns The details of the user with given rest id
+     * @param restId The screen name of the target user.
+     */
+    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;
+        }
+        
+        // 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);
+
+        // Caching data
+        this.cacheData(data);
+
+        // Parsing data
+        let user = UserDeserializers.toUser(data.required[0]);
+            
+        return user;
+    }
+
+    /**
+     * @returns The list of users followed by the target user
+     * @param userId The rest id of the target user
+     * @param count The number of following to fetch, should be >= 40 (when no cursor is provided) and <=100
+     * @param cursor The cursor to next batch. If blank, first batch is fetched
+     */
+    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 invalid count provided
+        if (count < 40 && !cursor) {
+            throw new Error(Errors.ValidationErrors.InvalidCount);
+        }
+
+        // Fetchin the raw data
+        let res = await this.request<RawUserFollowing>(UserUrls.userFollowingUrl(userId, count, cursor)).then(res => res.data);
+        
+        // Extracting data
+        let data = UserExtractors.extractUserFollow(res);
+
+        // Caching data
+        this.cacheData(data);
+
+        // Parsing data
+        let users = data.required.map((item: UserData) => UserDeserializers.toUser(item));
+
+        return {
+            list: users,
+            next: { value: data.cursor }
+        };
+    }
+
+    /**
+     * @returns The list of users following the target user
+     * @param userId The rest id of the target user
+     * @param count The number of followers to fetch, should be >= 40 (when no cursor is provided) and <=100
+     * @param cursor The cursor to next batch. If blank, first batch is fetched
+     */
+    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);
+        }
+
+        // If invalid count provided
+        if (count < 40 && !cursor) {
+            throw new Error(Errors.ValidationErrors.InvalidCount);
+        }
+
+        // Fetching the raw data
+        let res = await this.request<RawUserFollowers>(UserUrls.userFollowersUrl(userId, count, cursor)).then(res => res.data);
+        
+        // Extracting data
+        let data = UserExtractors.extractUserFollow(res);
+
+        // Caching data
+        this.cacheData(data);
+
+        // Parsing data
+        let users = data.required.map((item: UserData) => UserDeserializers.toUser(item));
+
+        return {
+            list: users,
+            next: { value: data.cursor }
+        };
+    }
+
+    /**
+     * @returns The list of tweets liked by the target user
+     * @param userId The rest id of the target user
+     * @param count The number of likes 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
+     */
+    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);
+        }
+
+        // If invalid count provided
+        if (count < 40 && !cursor) {
+            throw new Error(Errors.ValidationErrors.InvalidCount);
+        }
+
+        // Fetching the raw data
+        let res = await this.request<RawUserLikes>(UserUrls.userLikesUrl(userId, count, cursor)).then(res => res.data);
+        
+        // Extracting data
+        let data = UserExtractors.extractUserLikes(res);
+
+        // 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/helper/Parser.ts

@@ -1,4 +1,5 @@
-import { TweetFilter } from '../../types/Tweet';
+// TYPES
+import { TweetFilter } from '../../types/data/Tweet';
 
 /**
  * @returns Whether the given json object is empty or not
@@ -95,14 +96,15 @@ export function toQueryString(filter: TweetFilter): string {
     // Concatenating the input filter arguments to a URL query formatted string
     return [
         filter.words ? filter.words.join(' ') : '',
-        filter.hashtags ? `(${filter.hashtags.map(hashtag => '%23' + hashtag).join(' OR ')})` : '',
+        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 => '%40' + mention).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 ? '%20-filter%3Alinks' : '');
+    .join(' ') + (!filter.links ? ' -filter:links' : '');
 }

package/src/services/helper/{Deserializers.ts → deserializers/Tweets.ts}

@@ -1,34 +1,9 @@
 // TYPES
-import { User } from '../../types/UserAccount';
-import { Tweet, TweetEntities } from '../../types/Tweet';
-import { Result as RawUser } from '../../types/raw/user/User';
-import { Result as RawTweet, Entities2 as RawTweetEntities } from '../../types/raw/tweet/Tweet';
+import { Tweet, TweetEntities } from '../../../types/data/Tweet';
+import { Result as RawTweet, Entities2 as RawTweetEntities } from '../../../types/raw/tweet/Tweet';
 
 // PARSERS
-import * as Parsers from './Parser';
-
-/**
- * @returns A User object containing the user details
- * @param data The raw user data from Twitter API
- */
-export function toUser(data: RawUser): User {
-    return {
-        id: data.rest_id,
-        userName: data.legacy.screen_name,
-        fullName: data.legacy.name,
-        createdAt: data.legacy.created_at,
-        description: data.legacy.description,
-        isVerified: data.legacy.verified,
-        favouritesCount: data.legacy.favourites_count,
-        followersCount: data.legacy.followers_count,
-        followingsCount: data.legacy.friends_count,
-        statusesCount: data.legacy.statuses_count,
-        location: data.legacy.location,
-        pinnedTweet: data.legacy.pinned_tweet_ids_str[0],
-        profileBanner: data.legacy.profile_banner_url,
-        profileImage: data.legacy.profile_image_url_https
-    };
-}
+import * as Parsers from '../Parser';
 
 /**
  * @returns A TweetEntities object containing the various tweet entities

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

@@ -0,0 +1,26 @@
+// TYPES
+import { User } from '../../../types/data/User';
+import { Result as RawUser } from '../../../types/raw/user/User';
+
+/**
+ * @returns A User object containing the user details
+ * @param data The raw user data from Twitter API
+ */
+export function toUser(data: RawUser): User {
+    return {
+        id: data.rest_id,
+        userName: data.legacy.screen_name,
+        fullName: data.legacy.name,
+        createdAt: data.legacy.created_at,
+        description: data.legacy.description,
+        isVerified: data.legacy.verified,
+        favouritesCount: data.legacy.favourites_count,
+        followersCount: data.legacy.followers_count,
+        followingsCount: data.legacy.friends_count,
+        statusesCount: data.legacy.statuses_count,
+        location: data.legacy.location,
+        pinnedTweet: data.legacy.pinned_tweet_ids_str[0],
+        profileBanner: data.legacy.profile_banner_url,
+        profileImage: data.legacy.profile_image_url_https
+    };
+}