rettiwt-api 1.0.6 → 1.0.8

package/src/{resolvers → graphql/resolvers}/UserResolver.ts

@@ -2,15 +2,17 @@
 import ResolverBase from './ResolverBase';
 
 // TYPES
-import { Cursor, DataContext } from '../types/Service';
-
-// HELPERS
-import { ValidationErrors } from '../types/graphql/Errors';
+import { Cursor, DataContext } from '../../types/data/Service';
+import { DataErrors, ValidationErrors } from '../../types/data/Errors';
 
 export default class UserResolver extends ResolverBase {
+    // MEMBER DATA
+    private batchSize: number;                                                // To store the batch size when fetching data
+    
     // MEMBER METHODS
     constructor(context: DataContext) {
         super(context);
+        this.batchSize = 40;
     }
 
     /**
@@ -21,11 +23,11 @@ export default class UserResolver extends ResolverBase {
     async resolveUserDetails(userName: string, id: string): Promise<any> {
         // If user name is supplied
         if (userName) {
-            return await this.context.users.getUserAccountDetails(userName);
+            return await this.context.users.getUserDetails(userName);
         }
         // If id is supplied
         else if (id) {
-            return await this.context.users.getUserAccountDetailsById(id);
+            return await this.context.users.getUserDetailsById(id);
         }
         // If neither userName nor id is supplied
         else {
@@ -36,7 +38,7 @@ export default class UserResolver extends ResolverBase {
     /**
      * @returns The list of tweets liked by the given user
      * @param id The id of the user whose likes are to be fetched
-     * @param count The number of likes to fetch
+     * @param count The number of likes to fetch, must be >= 40
      * @param all Whether to fetch list of all tweets liked by user
      * @param cursor The cursor to the batch of likes to fetch
      * @param favouritesCount The total number of tweets liked by target user
@@ -44,22 +46,21 @@ export default class UserResolver extends ResolverBase {
     async resolveUserLikes(id: string, count: number, all: boolean, cursor: string, favouritesCount: number): Promise<any> {
         let likes: any[] = [];                                                      // To store the list of liked tweets
         let next: Cursor = new Cursor(cursor);                                      // To store cursor to next batch
-        let total: number = 0;                                                      // To store the total number of liked twets fetched
-        let batchSize: number = 20;                                                 // To store the batchsize to use
+        let total: number = 0;                                                      // To store the total number of liked tweets fetched
 
         // If all liked tweets are to be fetched
         count = all ? favouritesCount : count;
 
         // If required count less than batch size, setting batch size to required count
-        batchSize = (count < batchSize) ? count : batchSize;
+        this.batchSize = (count < this.batchSize) ? count : this.batchSize;
 
         // Repeatedly fetching data as long as total data fetched is less than requried
-        while (total < count) {
+        do {
             // If this is the last batch, change batch size to number of remaining tweets
-            batchSize = ((count - total) < batchSize) ? (count - total) : batchSize;
+            this.batchSize = ((count - total) < this.batchSize) ? (count - total) : this.batchSize;
 
             // Getting the data
-            const res = await this.context.users.getUserLikes(id, count, next.value);
+            const res = await this.context.users.getUserLikes(id, this.batchSize, next.value);
 
             // If data is available
             if (res.list?.length) {
@@ -76,6 +77,11 @@ export default class UserResolver extends ResolverBase {
             else {
                 break;
             }
+        } while (total < count);
+
+        // If no likes found
+        if (!likes.length) {
+            return new Error(DataErrors.NoLikedTweetsFound);
         }
 
         // Adding the cursor to the end of list of data
@@ -87,7 +93,7 @@ export default class UserResolver extends ResolverBase {
     /**
      * @returns The list of followers of the given twiiter user
      * @param id The id of the user whose followers are to be fetched
-     * @param count The number of followers to fetch
+     * @param count The number of followers to fetch, must be >= 40 when no cursor is provided
      * @param all Whether to fetch all followers list
      * @param cursor The cursor to the batch of followers to fetch
      * @param followerCount The total number of followers of the target user
@@ -96,21 +102,20 @@ export default class UserResolver extends ResolverBase {
         let followers: any[] = [];                                                  // To store the list of followers
         let next: Cursor = new Cursor(cursor);                                      // To store cursor to next batch
         let total: number = 0;                                                      // To store the total number of followers fetched
-        let batchSize: number = 20;                                                 // To store the batchsize to use
 
         // If all followers are to be fetched
-        count = (all || count > followersCount) ? followersCount : count;
+        count = all ? followersCount : count;
 
         // If required count less than batch size, setting batch size to required count
-        batchSize = (count < batchSize) ? count : batchSize;
+        this.batchSize = (count < this.batchSize) ? count : this.batchSize;
 
         // Repeatedly fetching data as long as total data fetched is less than requried
-        while (total < count) {
+        do {
             // If this is the last batch, change batch size to number of remaining followers
-            batchSize = ((count - total) < batchSize) ? (count - total) : batchSize;
+            this.batchSize = ((count - total) < this.batchSize) ? (count - total) : this.batchSize;
 
             // Getting the data
-            const res = await this.context.users.getUserFollowers(id, count, next.value);
+            const res = await this.context.users.getUserFollowers(id, this.batchSize, next.value);
 
             // If data is available
             if (res.list?.length) {
@@ -127,6 +132,11 @@ export default class UserResolver extends ResolverBase {
             else {
                 break;
             }
+        } while (total < count);
+
+        // If no followers found
+        if (!followers.length) {
+            return new Error(DataErrors.NoFollowsFound);
         }
 
         // Adding the cursor to the end of list of data
@@ -138,7 +148,7 @@ export default class UserResolver extends ResolverBase {
     /**
      * @returns The list of following of the given twiiter user
      * @param id The id of the user whose followings are to be fetched
-     * @param count The number of following to fetch
+     * @param count The number of following to fetch, should be >= 40 when no cursor is provided
      * @param all Whether to fetch list of all followings
      * @param cursor The cursor to the batch of followings to fetch
      * @param followingsCount The total number of followings of the target user
@@ -147,21 +157,20 @@ export default class UserResolver extends ResolverBase {
         let following: any[] = [];                                                  // To store the list of following
         let next: Cursor = new Cursor(cursor);                                      // To store cursor to next batch
         let total: number = 0;                                                      // To store the total number of following fetched
-        let batchSize: number = 20;                                                 // To store the batchsize to use
 
         // If all followings are to be fetched
-        count = (all || count > followingsCount) ? followingsCount : count;
+        count = all ? followingsCount : count;
 
         // If required count less than batch size, setting batch size to required count
-        batchSize = (count < batchSize) ? count : batchSize;
+        this.batchSize = (count < this.batchSize) ? count : this.batchSize;
 
         // Repeatedly fetching data as long as total data fetched is less than requried
-        while (total < count) {
+        do {
             // If this is the last batch, change batch size to number of remaining following
-            batchSize = ((count - total) < batchSize) ? (count - total) : batchSize;
+            this.batchSize = ((count - total) < this.batchSize) ? (count - total) : this.batchSize;
 
             // Getting the data
-            const res = await this.context.users.getUserFollowing(id, count, next.value);
+            const res = await this.context.users.getUserFollowing(id, this.batchSize, next.value);
 
             // If data is available
             if (res.list?.length) {
@@ -178,6 +187,11 @@ export default class UserResolver extends ResolverBase {
             else {
                 break;
             }
+        } while (total < count);
+
+        // If no following found
+        if (!following.length) {
+            return new Error(DataErrors.NoFollowsFound);
         }
 
         // Adding the cursor to the end of list of data

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: {
@@ -112,7 +110,12 @@ export const Tweet = new GraphQLObjectType({
             },
             resolve: (parent, args, context) => new TweetResolver(context).resolveTweetRetweeters(parent.id, args.count, args.all, args.cursor, parent.retweetCount)
         },
-        replyCount: { type: GraphQLInt },
+        replyCount: { type: GraphQLInt }
+        /**
+         * THIS IS DISABLED FOR USE FOR NOW BECAUSE TWITTER DOESN'T HAVE ANY ENDPOINT FOR FETCHING REPLIES.
+         * THE DATA THIS RETURNS IS INCONSISTENT!
+         */
+        /*
         replies: {
             type: TweetList,
             args: {
@@ -134,10 +137,11 @@ export const Tweet = new GraphQLObjectType({
             },
             resolve: (parent, args, context) => new TweetResolver(context).resolveTweetReplies(parent.id, args.count, args.all, args.cursor, parent.replyCount)
         }
+        */
     })
 });
 
-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);
     }
 }