rettiwt-api 1.4.0 → 2.0.1

package/src/graphql/resolvers/ResolverBase.ts

@@ -1,26 +0,0 @@
-// PACKAGES
-import { GraphQLError } from 'graphql'
-
-// TYPES
-import { IDataContext } from '../../types/Rettiwt';
-
-export default class ResolverBase {
-    /** The current data context that can used for fetching data from Twitter. */
-    protected context: IDataContext;
-
-    /**
-     * @param context The data context that will be used for fetching data from Twitter.
-     */
-    constructor(context: IDataContext) {
-        this.context = context;
-    }
-
-    /**
-     * @param error The error object received from the services.
-     * 
-     * @returns The GraphQL error object that can be returned to the client.
-     */
-    protected getGraphQLError(error: Error) {
-        return new GraphQLError(error.message, undefined, undefined, undefined, undefined, undefined, error);
-    }
-}

package/src/graphql/resolvers/TweetResolver.ts

@@ -1,225 +0,0 @@
-// PACKAGE
-import { TweetFilter } from 'rettiwt-core';
-
-// RESOLVERS
-import ResolverBase from './ResolverBase';
-
-// TYPES
-import { IDataContext } from '../../types/Rettiwt';
-import { Cursor } from '../../models/data/CursoredData';
-import { DataErrors } from '../enums/Errors';
-
-export default class TweetResolver extends ResolverBase {
-    // MEMBER DATA
-    private batchSize: number;                                              // To store the batch size while fetching data
-    // MEMBER METHODS
-    constructor(context: IDataContext) {
-        super(context);
-        this.batchSize = 100;
-    }
-
-    /**
-     * @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.getTweetDetails(id).catch(error => {
-            throw this.getGraphQLError(error);
-        });
-
-        // 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, must be >= 20 (when no cursor if provided)
-     * @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
-
-        /** The batch size while fetching tweets is lower (=20), compared to other data related to a tweet (=100). */
-        let batchSize: number = 20;
-
-        // 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
-        do {
-            // 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, batchSize, next.value).catch(error => {
-                throw this.getGraphQLError(error);
-            });
-
-            // 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 as Cursor;
-            }
-            // If no more data is available
-            else {
-                break;
-            }
-        } while (total < count);
-
-        // If no tweets found
-        if (!tweets.length) {
-            return new Error(DataErrors.NoTweetsFound);
-        }
-
-        // 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, must be >= 20 (when no cursor if provided)
-     * @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 ? quoteCount : count;
-
-        // Fetching the quotes using resolveTweets method
-        quotes = await this.resolveTweets({ quoted: id }, count, cursor).catch(error => {
-            throw this.getGraphQLError(error);
-        });
-
-        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, must be >= 10 (when no cursor is provided)
-     * @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
-
-        // If all likers are to be fetched
-        count = all ? likesCount : count;
-
-        // If required count less than batch size, setting batch size to required count
-        this.batchSize = (count < this.batchSize) ? count : this.batchSize;
-
-        // Repeatedly fetching data as long as total data fetched is less than requried
-        do {
-            // If this is the last batch, change batch size to number of remaining likers
-            this.batchSize = ((count - total) < this.batchSize) ? (count - total) : this.batchSize;
-
-            // Getting the data
-            const res = await this.context.tweets.getTweetLikers(id, this.batchSize, next.value).catch(error => {
-                throw this.getGraphQLError(error);
-            });
-
-            // 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 as Cursor;
-            }
-            // If no more data is available
-            else {
-                break;
-            }
-        } while (total < count);
-
-        // If no likers found
-        if (!likers.length) {
-            return new Error(DataErrors.NoLikersFound);
-        }
-
-        // 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, must be >= 10 (when no cursor is provided)
-     * @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
-
-        // If all retweeters are to be fetched
-        count = all ? retweetsCount : count;
-
-        // If required count less than batch size, setting batch size to required count
-        this.batchSize = (count < this.batchSize) ? count : this.batchSize;
-
-        // Repeatedly fetching data as long as total data fetched is less than requried
-        do {
-            // If this is the last batch, change batch size to number of remaining retweeters
-            this.batchSize = ((count - total) < this.batchSize) ? (count - total) : this.batchSize;
-
-            // Getting the data
-            const res = await this.context.tweets.getTweetRetweeters(id, this.batchSize, next.value).catch(error => {
-                throw this.getGraphQLError(error);
-            });
-
-            // 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 as Cursor;
-            }
-            // If no more data is available
-            else {
-                break;
-            }
-        } while (total < count);
-
-        // If no retweeters found
-        if (!retweeters.length) {
-            return new Error(DataErrors.NoRetweetersFound);
-        }
-
-        // Adding the cursor to the end of list of data
-        retweeters.push(next);
-
-        return retweeters;
-    }
-}

package/src/graphql/resolvers/UserResolver.ts

@@ -1,257 +0,0 @@
-// RESOLVERS
-import ResolverBase from './ResolverBase';
-
-// TYPES
-import { IDataContext } from '../../types/Rettiwt'
-import { Cursor } from '../../models/data/CursoredData';
-import { DataErrors } from '../enums/Errors';
-
-export default class UserResolver extends ResolverBase {
-    // MEMBER DATA
-    private batchSize: number;                                                // To store the batch size when fetching data
-
-    // MEMBER METHODS
-    constructor(context: IDataContext) {
-        super(context);
-        this.batchSize = 40;
-    }
-
-    /**
-     * @returns The details of the target twitter user
-     * @param userName The user name of the target twitter user
-     * @param id The id/username of the target twitter user
-     */
-    async resolveUserDetails(id: string): Promise<any> {
-        return await this.context.users.getUserDetails(id).catch(error => {
-            throw this.getGraphQLError(error);
-        });
-    }
-
-    /**
-     * @returns The list of tweets made by the given user
-     * @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(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
-
-        // If all tweets are to be fetched
-        count = all ? statusesCount : count;
-
-        // If required count less than batch size, setting batch size to required count
-        this.batchSize = (count < this.batchSize) ? count : this.batchSize;
-
-        // Repeatedly fetching data as long as total data fetched is less than requried
-        do {
-            // If this is the last batch, change batch size to number of remaining tweets
-            this.batchSize = ((count - total) < this.batchSize) ? (count - total) : this.batchSize;
-
-            // Getting the data
-            const res = await this.context.tweets.getTweets({ fromUsers: [userName] }, this.batchSize, next.value).catch(error => {
-                throw this.getGraphQLError(error);
-            });
-
-            // 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 as Cursor;
-            }
-            // If no more data is available
-            else {
-                break;
-            }
-        } while (total < count);
-
-        // If no likes found
-        if (!likes.length) {
-            return new Error(DataErrors.NoUserTweetsFound);
-        }
-
-        // Adding the cursor to the end of list of data
-        likes.push(next);
-
-        return likes;
-    }
-
-    /**
-     * @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, 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
-     */
-    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 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
-        this.batchSize = (count < this.batchSize) ? count : this.batchSize;
-
-        // Repeatedly fetching data as long as total data fetched is less than requried
-        do {
-            // If this is the last batch, change batch size to number of remaining tweets
-            this.batchSize = ((count - total) < this.batchSize) ? (count - total) : this.batchSize;
-
-            // Getting the data
-            const res = await this.context.users.getUserLikes(id, this.batchSize, next.value).catch(error => {
-                throw this.getGraphQLError(error);
-            });
-
-            // 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 as Cursor;
-            }
-            // If no more data is available
-            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
-        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, 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
-     */
-    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
-
-        // If all followers are to be fetched
-        count = all ? followersCount : count;
-
-        // If required count less than batch size, setting batch size to required count
-        this.batchSize = (count < this.batchSize) ? count : this.batchSize;
-
-        // Repeatedly fetching data as long as total data fetched is less than requried
-        do {
-            // If this is the last batch, change batch size to number of remaining followers
-            this.batchSize = ((count - total) < this.batchSize) ? (count - total) : this.batchSize;
-
-            // Getting the data
-            const res = await this.context.users.getUserFollowers(id, this.batchSize, next.value).catch(error => {
-                throw this.getGraphQLError(error);
-            });
-
-            // 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 as Cursor;
-            }
-            // If no more data is available
-            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
-        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, 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
-     */
-    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
-
-        // If all followings are to be fetched
-        count = all ? followingsCount : count;
-
-        // If required count less than batch size, setting batch size to required count
-        this.batchSize = (count < this.batchSize) ? count : this.batchSize;
-
-        // Repeatedly fetching data as long as total data fetched is less than requried
-        do {
-            // If this is the last batch, change batch size to number of remaining following
-            this.batchSize = ((count - total) < this.batchSize) ? (count - total) : this.batchSize;
-
-            // Getting the data
-            const res = await this.context.users.getUserFollowing(id, this.batchSize, next.value).catch(error => {
-                throw this.getGraphQLError(error);
-            });
-
-            // 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 as Cursor;
-            }
-            // If no more data is available
-            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
-        following.push(next);
-
-        return following;
-    }
-}

package/src/graphql/types/Global.ts

@@ -1,10 +0,0 @@
-// PACKAGE
-import { GraphQLString, GraphQLObjectType, } from "graphql";
-
-export const Cursor = new GraphQLObjectType({
-    name: 'Cursor',
-    description: 'Cursor data for the next batch of list data',
-    fields: () => ({
-        value: { type: GraphQLString }
-    })
-});

package/src/graphql/types/TweetTypes.ts

@@ -1,158 +0,0 @@
-// PACKAGE
-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";
-
-export const TweetTokens: GraphQLObjectType = new GraphQLObjectType({
-    name: 'TweetTokens',
-    description: 'Additional extracted tokens from the tweet like mentions, hashtags, etc',
-    fields: () => ({
-        hashtags: { type: new GraphQLList(GraphQLString) },
-        urls: { type: new GraphQLList(GraphQLString) },
-        mentionedUsers: {
-            type: UserList,
-            resolve: (parent, args, context) => parent.mentionedUsers.map((user: string) => new UserResolver(context).resolveUserDetails(user))
-        },
-        media: { type: new GraphQLList(GraphQLString) },
-    })
-});
-
-export const Tweet: GraphQLObjectType = new GraphQLObjectType({
-    name: 'Tweet',
-    description: 'The details of single tweet',
-    fields: () => ({
-        id: { type: GraphQLString },
-        tweetBy: {
-            type: User,
-            resolve: (parent, args, context) => new UserResolver(context).resolveUserDetails(parent.tweetBy)
-        },
-        createdAt: { type: GraphQLString },
-        entities: { type: TweetTokens },
-        quoted: {
-            type: Tweet,
-            resolve: (parent, args, context) => parent.quoted ? new TweetResolver(context).resolveTweet(parent.quoted) : undefined
-        },
-        fullText: { type: GraphQLString },
-        replyTo: {
-            type: Tweet,
-            resolve: (parent, args, context) => parent.replyTo ? new TweetResolver(context).resolveTweet(parent.replyTo) : undefined
-        },
-        lang: { type: GraphQLString },
-        quoteCount: { type: GraphQLInt },
-        quotes: {
-            type: TweetList,
-            args: {
-                count: {
-                    type: GraphQLInt,
-                    description: "The number of quotes to fetch, must be >= 1",
-                    defaultValue: 10
-                },
-                all: {
-                    type: GraphQLBoolean,
-                    description: "Whether to fetch all quotes",
-                    defaultValue: false
-                },
-                cursor: {
-                    type: GraphQLString,
-                    description: 'The cursor to the batch of quotes list to fetch',
-                    defaultValue: ''
-                }
-            },
-            resolve: (parent, args, context) => new TweetResolver(context).resolveTweetQuotes(parent.id, args.count, args.all, args.cursor, parent.quoteCount)
-        },
-        likeCount: { type: GraphQLInt },
-        likers: {
-            type: UserList,
-            args: {
-                count: {
-                    type: GraphQLInt,
-                    description: "The number of likers to fetch, must be >= 10 (when no cursor if provided)",
-                    defaultValue: 10
-                },
-                all: {
-                    type: GraphQLBoolean,
-                    description: "Whether to fetch all likers",
-                    defaultValue: false
-                },
-                cursor: {
-                    type: GraphQLString,
-                    description: 'The cursor to the batch of likers list to fetch',
-                    defaultValue: ''
-                }
-            },
-            resolve: (parent, args, context) => new TweetResolver(context).resolveTweetLikers(parent.id, args.count, args.all, args.cursor, parent.likeCount)
-        },
-        retweetCount: { type: GraphQLInt },
-        retweeters: {
-            type: UserList,
-            args: {
-                count: {
-                    type: GraphQLInt,
-                    description: "The number of retweeters to fetch, must be >= 10 (when no cursor if provided)",
-                    defaultValue: 10
-                },
-                all: {
-                    type: GraphQLBoolean,
-                    description: "Whether to fetch all likers",
-                    defaultValue: false
-                },
-                cursor: {
-                    type: GraphQLString,
-                    description: 'The cursor to the batch of retweeters list to fetch',
-                    defaultValue: ''
-                }
-            },
-            resolve: (parent, args, context) => new TweetResolver(context).resolveTweetRetweeters(parent.id, args.count, args.all, args.cursor, parent.retweetCount)
-        },
-        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: {
-                count: {
-                    type: GraphQLInt,
-                    description: "The number of replies to fetch",
-                    defaultValue: 10
-                },
-                all: {
-                    type: GraphQLBoolean,
-                    description: "Whether to fetch all replies",
-                    defaultValue: false
-                },
-                cursor: {
-                    type: GraphQLString,
-                    description: 'The cursor to the batch of replies list to fetch',
-                    defaultValue: ''
-                }
-            },
-            resolve: (parent, args, context) => new TweetResolver(context).resolveTweetReplies(parent.id, args.count, args.all, args.cursor, parent.replyCount)
-        }
-        */
-    })
-});
-
-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],
-    resolveType: (data) => {
-        // If it has fullText field => this is a Tweet object
-        if(data.fullText) {
-            return Tweet;
-        }
-        // If it has a value field => this is a cursor object
-        else if(data.value) {
-            return Cursor;
-        }
-    }
-}));