rettiwt-api 1.0.1

package/src/queries/RootQuery.ts

@@ -0,0 +1,56 @@
+// PACKAGE
+import { GraphQLBoolean, GraphQLInt, GraphQLList, GraphQLObjectType, GraphQLString } from 'graphql'
+
+// TYPES
+import { User } from '../models/graphql/UserTypes';
+import { Tweet, TweetList } from '../models/graphql/TweetTypes';
+import { TweetFilter } from '../types/Tweet';
+
+// RESOLVERS
+import UserResolver from '../resolvers/UserResolver';
+import TweetResolver from '../resolvers/TweetResolver';
+
+export const rootQuery = new GraphQLObjectType({
+    name: 'Root',
+    fields: {
+        test: {
+            type: GraphQLString,
+            resolve: () => "GraphQL Works!"
+        },
+        User: {
+            type: User,
+            description: "Returns the details of the twitter user with given user name",
+            args: {
+                userName: { type: GraphQLString },
+                id: { type: GraphQLString }
+            },
+            resolve: (parent, args, context) => new UserResolver(context).resolveUserDetails(args.userName, args.id)
+        },
+        Tweet: {
+            type: Tweet,
+            description: "Returns a single tweet given it's id",
+            args: {
+                id: { type: GraphQLString }
+            },
+            resolve: (parent, args, context) => new TweetResolver(context).resolveTweet(args.id)
+        },
+        Tweets: {
+            type: TweetList,
+            description: "Returns the list of tweets matching the given criteria",
+            args: {
+                fromUsers: { type: new GraphQLList(GraphQLString) },
+                toUsers: { type: new GraphQLList(GraphQLString) },
+                mentions: { type: new GraphQLList(GraphQLString) },
+                hashtags: { type: new GraphQLList(GraphQLString) },
+                words: { type: new GraphQLList(GraphQLString) },
+                startDate: { type: GraphQLString },
+                endDate: { type: GraphQLString },
+                quoted: { type: GraphQLString },
+                links: { type: GraphQLBoolean, defaultValue: false },
+                count: { type: GraphQLInt, defaultValue: 20 },
+                cursor: { type: GraphQLString, defaultValue: '' }
+            },
+            resolve: (parent, args, context) => new TweetResolver(context).resolveTweets(args as TweetFilter, args.count, args.cursor)
+        }
+    }
+})

package/src/resolvers/ResolverBase.ts

@@ -0,0 +1,12 @@
+// TYPES
+import { DataContext } from '../types/Service';
+
+export default class ResolverBase {
+    // MEMBER DATA
+    protected context: DataContext;                                         // To store the data context
+
+    // MEMBER METHODS
+    constructor(context: DataContext) {
+        this.context = context;
+    }
+}

package/src/resolvers/TweetResolver.ts

@@ -0,0 +1,257 @@
+// RESOLVERS
+import ResolverBase from './ResolverBase';
+
+// TYPES
+import { TweetFilter } from '../types/Tweet';
+import { Cursor, DataContext } from '../types/Service';
+
+// HELPERS
+import { ValidationErrors } from '../types/graphql/Errors';
+
+export default class TweetResolver extends ResolverBase {
+    // MEMBER METHODS
+    constructor(context: DataContext) {
+        super(context);
+    }
+    
+    /**
+     * @returns The details of the tweet with the given id
+     * @param id The id of the tweet which is to be fetched
+     */
+    async resolveTweet(id: string): Promise<any> {
+        // Getting the data
+        let res = await this.context.tweets.getTweetById(id);
+
+        // Evaluating response
+        return res;
+    }
+
+    /**
+     * @returns The list of tweets matching the given filter
+     * @param filter The filter to be used for fetching matching tweets
+     * @param count The number of tweets to fetch
+     * @param cursor The cursor to the batch of tweets to fetch
+     */
+    async resolveTweets(filter: TweetFilter, count: number, cursor: string): Promise<any[]> {
+        let tweets: 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
+        let batchSize: number = 20;                                                 // To store the batchsize to use
+
+        // Checking if the given tweet filter is valid or not
+        if (!(filter.fromUsers || filter.toUsers || filter.words || filter.hashtags || filter.mentions || filter.quoted)) {
+            throw new Error(ValidationErrors.InvalidTweetFilter);
+        }
+
+        // If required count less than batch size, setting batch size to required count
+        batchSize = (count < batchSize) ? count : batchSize;
+
+        // Repeatedly fetching data as long as total data fetched is less than requried
+        while (total < count) {
+            // If this is the last batch, change batch size to number of remaining tweets
+            batchSize = ((count - total) < batchSize) ? (count - total) : batchSize;
+
+            // Getting the data
+            const res = await this.context.tweets.getTweets(filter, count, next.value);
+
+            // If data is available
+            if (res.list.length) {
+                // Adding fetched tweets to list of tweets
+                tweets = tweets.concat(res.list);
+
+                // Updating total tweets fetched
+                total = tweets.length;
+
+                // Getting cursor to next batch
+                next = res.next;
+            }
+            // If no more data is available
+            else {
+                break;
+            }
+        }
+
+        // Adding the cursor to the end of list of data
+        tweets.push(next);
+
+        return tweets;
+    }
+
+    /**
+     * @returns The list of quotes of the given tweet
+     * @param id The id of the tweet whose quotes are to be fetched
+     * @param count The number of quotes to be fetched
+     * @param all Whether to fetch all quotes or not
+     * @param cursor The cursor to the batch of tweet quotes to fetch
+     * @param quoteCount The total number of quotes of the given tweet
+     */
+    async resolveTweetQuotes(id: string, count: number, all: boolean, cursor: string, quoteCount: number): Promise<any[]> {
+        let quotes: any[] = [];                                                     // To store the list of quotes
+
+        // If all tweets are to be fetched
+        count = (all || count > quoteCount) ? quoteCount : count;
+
+        // Preparing the filter to use
+        let filter = {
+            words: [],
+            hashtags: [],
+            fromUsers: [],
+            toUsers: [],
+            mentions: [],
+            startDate: '',
+            endDate: '',
+            quoted: id
+        };
+
+        // Fetching the quotes using resolveTweets method
+        quotes = await this.resolveTweets(filter, count, cursor);
+
+        return quotes;
+    }
+
+    /**
+     * @returns The list of likers of the given tweet
+     * @param id The id of the tweet whose likers are to be fetched
+     * @param count The total number of likers to fetch
+     * @param all Whether to fetch all the likers of the tweet
+     * @param cursor The cursor to the batch of likers to fetch
+     * @param likesCount The total number of like of the tweet
+     */
+    async resolveTweetLikers(id: string, count: number, all: boolean, cursor: string, likesCount: number): Promise<any[]> {
+        let likers: any[] = [];                                                     // To store the list of likers
+        let next: Cursor = new Cursor(cursor);                                      // To store cursor to next batch
+        let total: number = 0;                                                      // To store the total number of likers fetched
+        let batchSize: number = 20;                                                 // To store the batchsize to use
+
+        // If all likers are to be fetched
+        count = (all || count > likesCount) ? likesCount : count;
+
+        // If required count less than batch size, setting batch size to required count
+        batchSize = (count < batchSize) ? count : batchSize;
+
+        // Repeatedly fetching data as long as total data fetched is less than requried
+        while (total < count) {
+            // If this is the last batch, change batch size to number of remaining likers
+            batchSize = ((count - total) < batchSize) ? (count - total) : batchSize;
+
+            // Getting the data
+            const res = await this.context.tweets.getTweetLikers(id, count, next.value);
+
+            // If data is available
+            if (res.list.length) {
+                // Adding fetched likers to list of likers
+                likers = likers.concat(res.list);
+
+                // Updating total likers fetched
+                total = likers.length;
+
+                // Getting cursor to next batch
+                next = res.next;
+            }
+            // If no more data is available
+            else {
+                break;
+            }
+        }
+
+        // Adding the cursor to the end of list of data
+        likers.push(next);
+
+        return likers;
+    }
+
+    /**
+     * @returns The list of retweeters of the given tweet
+     * @param id The id of the tweet whose retweeters are to be fetched
+     * @param count The total number of retweeters to fetch
+     * @param all Whether to fetch all retweeters
+     * @param cursor The cursor to the batch of retweeters to fetch
+     * @param retweetsCount The total number of retweets of the 
+     */
+    async resolveTweetRetweeters(id: string, count: number, all: boolean, cursor: string, retweetsCount: number): Promise<any[]> {
+        let retweeters: any[] = [];                                                 // To store the list of retweeters
+        let next: Cursor = new Cursor(cursor);                                      // To store cursor to next batch
+        let total: number = 0;                                                      // To store the total number of retweeters fetched
+        let batchSize: number = 20;                                                 // To store the batchsize to use
+
+        // If all retweeters are to be fetched
+        count = (all || count > retweetsCount) ? retweetsCount : count;
+
+        // If required count less than batch size, setting batch size to required count
+        batchSize = (count < batchSize) ? count : batchSize;
+
+        // Repeatedly fetching data as long as total data fetched is less than requried
+        while (total < count) {
+            // If this is the last batch, change batch size to number of remaining retweeters
+            batchSize = ((count - total) < batchSize) ? (count - total) : batchSize;
+
+            // Getting the data
+            const res = await this.context.tweets.getTweetRetweeters(id, count, next.value);
+
+            // If data is available
+            if (res.list.length) {
+                // Adding fetched retweeters to list of retweeters
+                retweeters = retweeters.concat(res.list);
+
+                // Updating total retweeters fetched
+                total = retweeters.length;
+
+                // Getting cursor to next batch
+                next = res.next;
+            }
+            // If no more data is available
+            else {
+                break;
+            }
+        }
+
+        // Adding the cursor to the end of list of data
+        retweeters.push(next);
+
+        return retweeters;
+    }
+
+    /**
+     * @returns The list of replies of the given tweet
+     * @param id The id of the tweet whose replies are to be fetched
+     * @param count The total number of replies to fetch
+     * @param all Whether to fetch list of all replies
+     * @param cursor The cursor to the batch of replies to fetch
+     * @param repliesCount The total number of replies to the target tweet
+     */
+    async resolveTweetReplies(id: string, count: number, all: boolean, cursor: string, repliesCount: number): Promise<any[]> {
+        let replies: any[] = [];                                                    // To store the list of replies
+        let next: Cursor = new Cursor(cursor);                                      // To store cursor to next batch
+        let total: number = 0;                                                      // To store the total number of replies fetched
+
+        // If all replies are to be fetched
+        count = (all || count > repliesCount) ? repliesCount : count;
+
+        // Repeatedly fetching data as long as total data fetched is less than requried
+        while (total < count) {
+            // Getting the data
+            const res = await this.context.tweets.getTweetReplies(id, next.value);
+
+            // If data is available
+            if (res.list.length) {
+                // Adding fetched replies to list of replies
+                replies = replies.concat(res.list);
+
+                // Updating total replies fetched
+                total = replies.length;
+
+                // Getting cursor to next batch
+                next = res.next;
+            }
+            // If no more data is available
+            else {
+                break;
+            }
+        }
+
+        // Adding the cursor to the end of list of data
+        replies.push(next);
+
+        return replies;
+    }
+}

package/src/resolvers/UserResolver.ts

@@ -0,0 +1,239 @@
+// RESOLVERS
+import ResolverBase from './ResolverBase';
+
+// TYPES
+import { Cursor, DataContext } from '../types/Service';
+
+// HELPERS
+import { ValidationErrors } from '../types/graphql/Errors';
+
+export default class UserResolver extends ResolverBase {
+    // MEMBER METHODS
+    constructor(context: DataContext) {
+        super(context);
+    }
+
+    /**
+     * @returns The details of the target twitter user
+     * @param userName The user name of the target twitter user
+     * @param id The id of the target twitter user
+     */
+    async resolveUserDetails(userName: string, id: string): Promise<any> {
+        // If user name is supplied
+        if (userName) {
+            return await this.context.users.getUserAccountDetails(userName);
+        }
+        // If id is supplied
+        else if (id) {
+            return await this.context.users.getUserAccountDetailsById(id);
+        }
+        // If neither userName nor id is supplied
+        else {
+            throw new Error(ValidationErrors.NoUserIdentification);
+        }
+    }
+
+    /**
+     * @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 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
+     */
+    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
+
+        // 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;
+
+        // Repeatedly fetching data as long as total data fetched is less than requried
+        while (total < count) {
+            // If this is the last batch, change batch size to number of remaining tweets
+            batchSize = ((count - total) < batchSize) ? (count - total) : batchSize;
+
+            // Getting the data
+            const res = await this.context.users.getUserLikes(id, count, next.value);
+
+            // If data is available
+            if (res.list.length) {
+                // Adding fetched tweets to list of tweets
+                likes = likes.concat(res.list);
+
+                // Updating total tweets fetched
+                total = likes.length;
+
+                // Getting cursor to next batch
+                next = res.next;
+            }
+            // If no more data is available
+            else {
+                break;
+            }
+        }
+
+        // Adding the cursor to the end of list of data
+        likes.push(next);
+
+        return likes;
+    }
+
+    /**
+     * @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 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
+     */
+    async resolveUserFollowers(id: string, count: number, all: boolean, cursor: string, followersCount: number): Promise<any> {
+        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;
+
+        // If required count less than batch size, setting batch size to required count
+        batchSize = (count < batchSize) ? count : batchSize;
+
+        // Repeatedly fetching data as long as total data fetched is less than requried
+        while (total < count) {
+            // If this is the last batch, change batch size to number of remaining followers
+            batchSize = ((count - total) < batchSize) ? (count - total) : batchSize;
+
+            // Getting the data
+            const res = await this.context.users.getUserFollowers(id, count, next.value);
+
+            // If data is available
+            if (res.list.length) {
+                // Adding fetched followers to list of followers
+                followers = followers.concat(res.list);
+
+                // Updating total followers fetched
+                total = followers.length;
+
+                // Getting cursor to next batch
+                next = res.next;
+            }
+            // If no more data is available
+            else {
+                break;
+            }
+        }
+
+        // Adding the cursor to the end of list of data
+        followers.push(next);
+
+        return followers;
+    }
+
+    /**
+     * @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 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
+     */
+    async resolveUserFollowing(id: string, count: number, all: boolean, cursor: string, followingsCount: number): Promise<any> {
+        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;
+
+        // If required count less than batch size, setting batch size to required count
+        batchSize = (count < batchSize) ? count : batchSize;
+
+        // Repeatedly fetching data as long as total data fetched is less than requried
+        while (total < count) {
+            // If this is the last batch, change batch size to number of remaining following
+            batchSize = ((count - total) < batchSize) ? (count - total) : batchSize;
+
+            // Getting the data
+            const res = await this.context.users.getUserFollowing(id, count, next.value);
+
+            // If data is available
+            if (res.list.length) {
+                // Adding fetched following to list of following
+                following = following.concat(res.list);
+
+                // Updating total following fetched
+                total = following.length;
+
+                // Getting cursor to next batch
+                next = res.next;
+            }
+            // If no more data is available
+            else {
+                break;
+            }
+        }
+
+        // Adding the cursor to the end of list of data
+        following.push(next);
+
+        return following;
+    }
+
+    /**
+     * @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
+     * @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> {
+        let tweets: 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
+        let batchSize: number = 20;                                                 // To store the batchsize to use
+
+        // If all tweets are to be fetched
+        count = all ? statusesCount : count;
+
+        // If required count less than batch size, setting batch size to required count
+        batchSize = (count < batchSize) ? count : batchSize;
+
+        // Repeatedly fetching data as long as total data fetched is less than requried
+        while (total < count) {
+            // If this is the last batch, change batch size to number of remaining tweets
+            batchSize = ((count - total) < batchSize) ? (count - total) : batchSize;
+
+            // Getting the data
+            const res = await this.context.users.getUserTweets(id, count, next.value);
+
+            // If data is available
+            if (res.list.length) {
+                // Adding fetched tweets to list of tweets
+                tweets = tweets.concat(res.list);
+
+                // Updating total tweets fetched
+                total = tweets.length;
+
+                // Getting cursor to next batch
+                next = res.next;
+            }
+            // If no more data is available
+            else {
+                break;
+            }
+        }
+
+        // Adding the cursor to the end of list of data
+        tweets.push(next);
+
+        return tweets;
+    }
+}

package/src/server.ts

@@ -0,0 +1,36 @@
+// PACKAGE
+import express from 'express';
+import { graphqlHTTP } from 'express-graphql';
+import { GraphQLSchema } from 'graphql';
+
+// Services
+import { UserAccountService } from './services/data/UserAccountService';
+import { TweetService } from './services/data/TweetService';
+import { AuthService } from './services/AuthService';
+
+// SCHEMA
+import { rootQuery } from './queries/RootQuery';
+
+// CONFIGS
+import { config } from './config/env';
+
+// Initialising express instance
+const app = express();
+
+// Setting up graphql endpoint
+app.use('/graphql', graphqlHTTP(req => ({
+    schema: new GraphQLSchema({
+        query: rootQuery
+    }),
+    context: {
+        users: new UserAccountService(new AuthService(req.headers.cookie as string)),
+        tweets: new TweetService(new AuthService(req.headers.cookie as string))
+    },
+    // If app is running in development environment, enable graphiql
+    graphiql: config.is_development
+})));
+
+// Setting up express server
+app.listen(config.port, async () => {
+    console.log(`Listening on port ${config.port}`);
+});

package/src/services/AuthService.ts

@@ -0,0 +1,58 @@
+// PACKAGE
+import axios from 'axios';
+
+// URLS
+import { guestTokenUrl } from './helper/Urls';
+
+// TYPES
+import { GuestCredentials, AuthCredentials } from '../types/Authentication';
+
+// CONFIGS
+import { config } from '../config/env';
+
+/**
+ * @summary Handles authentication of http requests and other authentication related tasks
+ */
+export class AuthService {
+    // MEMBER DATA
+    private authToken: string;                                               // To store the common auth token
+    private credentials: AuthCredentials;                                    // To store the current authentication credentials
+
+    // MEMBER METHODS
+    constructor(cookie: string = '') {
+        // Reading the auth token from the config, since it's always the same
+        this.authToken = config.twitter_auth_token;
+
+        // Setting up the authenticated credentials
+        /**
+         * The following regex pattern is used to extract the csrfToken from the cookie string.
+         * This is done by matching any string between the characters 'ct0=' and nearest enclosing ';'.
+         * (?<=pattern) starts matching after the given pattern.
+         * (?=pattern) stops matching just before the pattern
+         */
+        this.credentials = { authToken: this.authToken, csrfToken: cookie.match(/(?<=ct0=).+?(?=;)/) + '', cookie: cookie};
+        
+    }
+    
+    /**
+     * @returns The current authentication credentials. A different credential is returned each time this is invoked
+     */
+    async getAuthCredentials(): Promise<AuthCredentials> {
+        return this.credentials;
+    }
+
+    /**
+     * @returns The guest credentials fetched from twitter
+     */
+    async getGuestCredentials(): Promise<GuestCredentials> {
+        // Getting the guest credentials from twitter
+        return await axios.post<{ guest_token: string }>(guestTokenUrl(), null, {
+            headers: {
+                'Authorization': this.authToken
+            }
+        }).then(res => ({
+            authToken: this.authToken,
+            guestToken: res.data.guest_token
+        }));
+    }
+}