rettiwt-api 1.0.6 → 1.0.7

package/src/{models/graphql → graphql/types}/TweetTypes.ts

@@ -1,16 +1,15 @@
 // PACKAGE
-import { GraphQLList, GraphQLString, GraphQLObjectType, GraphQLInt, GraphQLBoolean, GraphQLUnionType } from "graphql";
+import { GraphQLList, GraphQLString, GraphQLObjectType, GraphQLInt, GraphQLBoolean, GraphQLUnionType, GraphQLType } from "graphql";
 
 // TYPES
 import { User, UserList } from './UserTypes';
 import { Cursor } from './Global';
 
 // RESOLVERS
-import TweetResolver from '../../resolvers/TweetResolver';
-import UserResolver from "../../resolvers/UserResolver";
+import TweetResolver from '../resolvers/TweetResolver';
+import UserResolver from "../resolvers/UserResolver";
 
-//@ts-ignore
-export const TweetTokens = new GraphQLObjectType({
+export const TweetTokens: GraphQLObjectType = new GraphQLObjectType({
     name: 'TweetTokens',
     description: 'Additional extracted tokens from the tweet like mentions, hashtags, etc',
     fields: () => ({
@@ -24,8 +23,7 @@ export const TweetTokens = new GraphQLObjectType({
     })
 });
 
-//@ts-ignore
-export const Tweet = new GraphQLObjectType({
+export const Tweet: GraphQLObjectType = new GraphQLObjectType({
     name: 'Tweet',
     description: 'The details of single tweet',
     fields: () => ({
@@ -52,7 +50,7 @@ export const Tweet = new GraphQLObjectType({
             args: {
                 count: {
                     type: GraphQLInt,
-                    description: "The number of quotes to fetch",
+                    description: "The number of quotes to fetch, must be >= 1",
                     defaultValue: 10
                 },
                 all: {
@@ -74,7 +72,7 @@ export const Tweet = new GraphQLObjectType({
             args: {
                 count: {
                     type: GraphQLInt,
-                    description: "The number of likers to fetch",
+                    description: "The number of likers to fetch, must be >= 10 (when no cursor if provided)",
                     defaultValue: 10
                 },
                 all: {
@@ -96,7 +94,7 @@ export const Tweet = new GraphQLObjectType({
             args: {
                 count: {
                     type: GraphQLInt,
-                    description: "The number of retweeters to fetch",
+                    description: "The number of retweeters to fetch, must be >= 10 (when no cursor if provided)",
                     defaultValue: 10
                 },
                 all: {
@@ -137,7 +135,7 @@ export const Tweet = new GraphQLObjectType({
     })
 });
 
-export const TweetList = new GraphQLList(new GraphQLUnionType({
+export const TweetList: GraphQLList<GraphQLType> = new GraphQLList(new GraphQLUnionType({
     name: 'TweetCursorUnion',
     description: 'A union type which can either be a Tweet or a Cursor, used in cursored tweet lists',
     types: [Tweet, Cursor],

package/src/{models/graphql → graphql/types}/UserTypes.ts

@@ -1,17 +1,16 @@
 // PACKAGE
-import { GraphQLBoolean, GraphQLObjectType, GraphQLString, GraphQLInt, GraphQLList, GraphQLUnionType } from 'graphql';
+import { GraphQLBoolean, GraphQLObjectType, GraphQLString, GraphQLInt, GraphQLList, GraphQLUnionType, GraphQLType } from 'graphql';
 
 // TYPES
 import { Tweet, TweetList } from './TweetTypes'
 import { Cursor } from './Global';
-import { TweetFilter } from '../../types/Tweet';
+import { TweetFilter } from '../../types/data/Tweet';
 
 // RESOLVERS
-import UserResolver from '../../resolvers/UserResolver';
-import TweetResolver from '../../resolvers/TweetResolver';
+import UserResolver from '../resolvers/UserResolver';
+import TweetResolver from '../resolvers/TweetResolver';
 
-//@ts-ignore
-export const User = new GraphQLObjectType({
+export const User: GraphQLObjectType = new GraphQLObjectType({
     name: 'User',
     description: 'The details of a single target twitter user',
     fields: () => ({
@@ -33,7 +32,7 @@ export const User = new GraphQLObjectType({
             type: TweetList,
             args: {
                 count: {
-                    description: "The number of liked tweets to fetch",
+                    description: "The number of liked tweets to fetch, must be >= 40 (when no cursor if provided)",
                     type: GraphQLInt,
                     defaultValue: 10
                 },
@@ -55,9 +54,9 @@ export const User = new GraphQLObjectType({
             type: UserList,
             args: {
                 count: {
-                    description: "The number of followers to fetch",
+                    description: "The number of followers to fetch, must be >= 40 (when no cursor is provided)",
                     type: GraphQLInt,
-                    defaultValue: 20
+                    defaultValue: 40
                 },
                 all: {
                     description: "Whether to fetch all followers list",
@@ -78,8 +77,8 @@ export const User = new GraphQLObjectType({
             args: {
                 count: {
                     type: GraphQLInt,
-                    description: "The number of followings to fetch",
-                    defaultValue: 20
+                    description: "The number of followings to fetch, must be >= 40 (when no cursor is provided)",
+                    defaultValue: 40
                 },
                 all: {
                     description: "Whether to fetch all followings list",
@@ -99,7 +98,7 @@ export const User = new GraphQLObjectType({
             type: TweetList,
             args: {
                 count: {
-                    description: "The number of tweets to fetch",
+                    description: "The number of tweets to fetch, must be >= 1",
                     type: GraphQLInt,
                     defaultValue: 10
                 },
@@ -114,13 +113,12 @@ export const User = new GraphQLObjectType({
                     defaultValue: ''
                 }
             },
-            resolve: (parent, args, context) => new TweetResolver(context).resolveTweets({ fromUsers: [parent.userName] } as TweetFilter, args.count, args.cursor)
+            resolve: (parent, args, context) => new TweetResolver(context).resolveTweets({ fromUsers: [parent.userName] } as TweetFilter, args.all ? parent.statusesCount : args.count, args.cursor)
         }
     })
 });
 
-//@ts-ignore
-export const UserList = new GraphQLList(new GraphQLUnionType({
+export const UserList: GraphQLList<GraphQLType> = new GraphQLList(new GraphQLUnionType({
     name: 'UserCursorUnion',
     description: 'A union type which can either be a User or a Cursor, used in cursored User lists',
     types: [User, Cursor],

package/src/index.ts

@@ -1,6 +1,6 @@
 // SERVICES
 import { AuthService } from "./services/AuthService";
-import { UserAccountService } from "./services/data/UserAccountService";
+import { UserService } from "./services/data/UserService";
 import { TweetService } from "./services/data/TweetService";
 import { AccountService } from "./services/accounts/AccountService";
 
@@ -14,7 +14,7 @@ export const Rettiwt = (cookie: string = '') => {
 
     // Using the auth service instance to create data services instances
     return {
-        users: new UserAccountService(auth),
+        users: new UserService(auth),
         tweets: new TweetService(auth),
         account: new AccountService()
     };

package/src/server.ts

@@ -4,13 +4,13 @@ import { graphqlHTTP } from 'express-graphql';
 import { GraphQLSchema } from 'graphql';
 
 // Services
-import { UserAccountService } from './services/data/UserAccountService';
+import { UserService } from './services/data/UserService';
 import { TweetService } from './services/data/TweetService';
 import { AccountService } from './services/accounts/AccountService';
 import { AuthService } from './services/AuthService';
 
 // SCHEMA
-import { rootQuery } from './queries/RootQuery';
+import { rootQuery } from './graphql/queries/RootQuery';
 
 // CONFIGS
 import { config } from './config/env';
@@ -24,7 +24,7 @@ app.use('/graphql', graphqlHTTP(req => ({
         query: rootQuery
     }),
     context: {
-        users: new UserAccountService(new AuthService(req.headers.cookie as string)),
+        users: new UserService(new AuthService(req.headers.cookie as string)),
         tweets: new TweetService(new AuthService(req.headers.cookie as string)),
         account: new AccountService()
     },

package/src/services/AuthService.ts

@@ -2,7 +2,7 @@
 import axios from 'axios';
 
 // URLS
-import { guestTokenUrl } from './helper/Urls';
+import { guestTokenUrl } from './helper/urls/Authentication';
 
 // TYPES
 import { GuestCredentials, AuthCredentials } from '../types/Authentication';

package/src/services/CacheService.ts

@@ -23,16 +23,14 @@ export class CacheService {
     /**
      * @returns The current working instance of CacheService
      */
-    static async getInstance(): Promise<CacheService> {
+    static getInstance(): CacheService {
         // If an instance doesnt exists already
         if (!this.instance) {
             this.instance = new CacheService();
-            return this.instance;
-        }
-        // If an instance already exists, returning it
-        else {
-            return this.instance;
         }
+        
+        // Returning the current instance
+        return this.instance;
     }
 
     /**
@@ -40,7 +38,7 @@ export class CacheService {
      * @returns Whether writing to cache was successful or not
      * @param data The input data to store
      */
-    async write(data: any): Promise<void> {
+    public write(data: any): void {
         // Converting the data to a list of data
         data = Parsers.dataToList(data);
 
@@ -61,7 +59,7 @@ export class CacheService {
      * @returns The data with the given id/rest id from cache
      * @param id The id/rest id of the data to be fetched from cache
      */
-    async read(id: string): Promise<any> {
+    public read(id: string): any {
         // Getting data from cache
         let res = this.client.get(id);
 

package/src/services/FetcherService.ts

@@ -12,7 +12,8 @@ import { Result as RawTweet } from '../types/raw/tweet/Tweet';
 
 // HELPERS
 import * as Headers from './helper/Headers'
-import * as Deserializers from './helper/Deserializers';
+import * as UserDeserializers from './helper/deserializers/Users';
+import * as TweetDeserializers from './helper/deserializers/Tweets';
 import { CurlyOptions } from 'node-libcurl/dist/curly';
 
 /**
@@ -29,11 +30,13 @@ export enum HttpMethods {
 export class FetcherService {
     // MEMBER DATA
     private auth: AuthService;                                              // To store the auth service instance to use for authentication
+    private cache: CacheService;                                            // To stoer the cache service instance to use for caching data
     protected isAuthenticated: boolean;                                     // To store whether user is authenticated or not
 
     // MEMBER METHODS
     constructor(auth: AuthService) {
         this.auth = auth;
+        this.cache = CacheService.getInstance();
         this.isAuthenticated = this.auth.isAuthenticated;
     }
 
@@ -77,28 +80,22 @@ export class FetcherService {
      * @summary Caches the extracted data
      * @param data The extracted data to be cached
      */
-    protected async cacheData(data: any): Promise<void> {
-        // Creating an instance of cache
-        let cache = await CacheService.getInstance();
-
+    protected cacheData(data: any): void {
         // Parsing the extracted data
-        let users = data.users.map((user: RawUser) => Deserializers.toUser(user));
-        let tweets = data.tweets.map((tweet: RawTweet) => Deserializers.toTweet(tweet));
+        let users = data.users.map((user: RawUser) => UserDeserializers.toUser(user));
+        let tweets = data.tweets.map((tweet: RawTweet) => TweetDeserializers.toTweet(tweet));
 
         // Caching the data
-        cache.write(users);
-        cache.write(tweets);
+        this.cache.write(users);
+        this.cache.write(tweets);
     }
 
     /**
      * @returns The data with the given id (if it exists in cache)
      * @param id The id of the data to be read from cache
      */
-    protected async readData(id: string): Promise<any> {
-        // Creating an instance of cache
-        let cache = await CacheService.getInstance();
-
+    protected readData(id: string): any {
         // Reading data from cache
-        return cache.read(id);
+        return this.cache.read(id);
     }
 }

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,
@@ -155,20 +171,20 @@ export class TweetService extends FetcherService {
     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,