rettiwt-api 1.0.6 → 1.0.7

package/dist/types/data/Tweet.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @summary Stores the filter to be used for fetching tweets from TwitterAPI
+ */
+export interface TweetFilter {
+    words?: string[];
+    hashtags?: string[];
+    fromUsers?: string[];
+    toUsers?: string[];
+    mentions?: string[];
+    startDate?: string;
+    endDate?: string;
+    sinceId?: string;
+    quoted?: string;
+    links?: boolean;
+}
+/**
+ * @summary Stores the different types of tweet elements like urls, media, mentions, hashtags, etc
+ */
+export interface TweetEntities {
+    hashtags: string[];
+    urls: string[];
+    mentionedUsers: string[];
+    media: string[];
+}
+/**
+ * @summary Stores a single tweet
+ */
+export interface Tweet {
+    id: string;
+    tweetBy: string;
+    createdAt: string;
+    entities: TweetEntities;
+    quoted: string;
+    fullText: string;
+    replyTo: string;
+    lang: string;
+    quoteCount: number;
+    replyCount: number;
+    retweetCount: number;
+    likeCount: number;
+}

package/dist/types/data/Tweet.js

@@ -0,0 +1,5 @@
+"use strict";
+// This file contains various objects related to handling of Tweets made by a user
+exports.__esModule = true;
+;
+//# sourceMappingURL=Tweet.js.map

package/dist/types/data/Tweet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Tweet.js","sourceRoot":"","sources":["../../../src/types/data/Tweet.ts"],"names":[],"mappings":";AAAA,kFAAkF;;AAgBjF,CAAC"}

package/dist/types/data/User.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @summary Stores the complete details of the given user's account
+ */
+export interface User {
+    id: string;
+    userName: string;
+    fullName: string;
+    createdAt: string;
+    description: string;
+    isVerified: boolean;
+    favouritesCount: number;
+    followersCount: number;
+    followingsCount: number;
+    statusesCount: number;
+    location: string;
+    pinnedTweet: string;
+    profileBanner: string;
+    profileImage: string;
+}

package/dist/types/data/User.js

@@ -0,0 +1,4 @@
+"use strict";
+// This file contains various objects for handling data related to User Account
+exports.__esModule = true;
+//# sourceMappingURL=User.js.map

package/dist/types/data/User.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"User.js","sourceRoot":"","sources":["../../../src/types/data/User.ts"],"names":[],"mappings":";AAAA,+EAA+E"}

package/dist/types/raw/http/Error.d.ts

@@ -0,0 +1,34 @@
+export interface Root {
+    errors: Error[];
+    data: Data;
+}
+export interface Error {
+    message: string;
+    locations: Location[];
+    path: string[];
+    extensions: Extensions;
+    code: number;
+    kind: string;
+    name: string;
+    source: string;
+    tracing: Tracing2;
+}
+export interface Location {
+    line: number;
+    column: number;
+}
+export interface Extensions {
+    name: string;
+    source: string;
+    code: number;
+    kind: string;
+    tracing: Tracing;
+}
+export interface Tracing {
+    trace_id: string;
+}
+export interface Tracing2 {
+    trace_id: string;
+}
+export interface Data {
+}

package/dist/types/raw/{user/Users.js → http/Error.js}

@@ -1,3 +1,3 @@
 "use strict";
 exports.__esModule = true;
-//# sourceMappingURL=Users.js.map
+//# sourceMappingURL=Error.js.map

package/dist/types/raw/http/Error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Error.js","sourceRoot":"","sources":["../../../../src/types/raw/http/Error.ts"],"names":[],"mappings":""}

package/dist/types/raw/http/Response.d.ts

@@ -0,0 +1,34 @@
+export default interface Reponse<Type> {
+    errors: Error[];
+    data: Type;
+}
+export interface Error {
+    message: string;
+    locations: Location[];
+    path: string[];
+    extensions: Extensions;
+    code: number;
+    kind: string;
+    name: string;
+    source: string;
+    tracing: Tracing2;
+}
+export interface Location {
+    line: number;
+    column: number;
+}
+export interface Extensions {
+    name: string;
+    source: string;
+    code: number;
+    kind: string;
+    tracing: Tracing;
+}
+export interface Tracing {
+    trace_id: string;
+}
+export interface Tracing2 {
+    trace_id: string;
+}
+export interface Data {
+}

package/dist/types/raw/http/Response.js

@@ -0,0 +1,3 @@
+"use strict";
+exports.__esModule = true;
+//# sourceMappingURL=Response.js.map

package/dist/types/raw/http/Response.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Response.js","sourceRoot":"","sources":["../../../../src/types/raw/http/Response.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "rettiwt-api",
-	"version": "1.0.6",
+	"version": "1.0.7",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"description": "An API for fetching data from TwitterAPI, without any rate limits!",

package/src/{queries → graphql/queries}/RootQuery.ts

@@ -2,9 +2,9 @@
 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';
+import { User } from '../types/UserTypes';
+import { Tweet, TweetList } from '../types/TweetTypes';
+import { TweetFilter } from '../../types/data/Tweet';
 
 // RESOLVERS
 import UserResolver from '../resolvers/UserResolver';
@@ -46,9 +46,10 @@ export const rootQuery = new GraphQLObjectType({
                 words: { type: new GraphQLList(GraphQLString) },
                 startDate: { type: GraphQLString },
                 endDate: { type: GraphQLString },
+                sinceId: { type: GraphQLString },
                 quoted: { type: GraphQLString },
                 links: { type: GraphQLBoolean, defaultValue: false },
-                count: { type: GraphQLInt, defaultValue: 20 },
+                count: { type: GraphQLInt, defaultValue: 10 },
                 cursor: { type: GraphQLString, defaultValue: '' }
             },
             resolve: (parent, args, context) => new TweetResolver(context).resolveTweets(args as TweetFilter, args.count, args.cursor)

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

@@ -1,22 +1,22 @@
-// RESOLVERS
-import ResolverBase from './ResolverBase';
-
-// TYPES
-import { DataContext } from '../types/Service';
-
-export default class AccountResolver extends ResolverBase {
-    // MEMBER METHODS
-    constructor(context: DataContext) {
-        super(context);
-    }
-
-    /**
-     * @param email The email of the account to be logged into
-     * @param userName The username associated with the account
-     * @param password The password to the account
-     * @returns The cookie string that can be used to authenticate against twitter
-     */
-    async resolveLogin(email: string, userName: string, password: string): Promise<string> {
-        return await this.context.account.login(email, userName, password);
-    }
+// RESOLVERS
+import ResolverBase from './ResolverBase';
+
+// TYPES
+import { DataContext } from '../../types/data/Service';
+
+export default class AccountResolver extends ResolverBase {
+    // MEMBER METHODS
+    constructor(context: DataContext) {
+        super(context);
+    }
+
+    /**
+     * @param email The email of the account to be logged into
+     * @param userName The username associated with the account
+     * @param password The password to the account
+     * @returns The cookie string that can be used to authenticate against twitter
+     */
+    async resolveLogin(email: string, userName: string, password: string): Promise<string> {
+        return await this.context.account.login(email, userName, password);
+    }
 }

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

@@ -1,5 +1,5 @@
 // TYPES
-import { DataContext } from '../types/Service';
+import { DataContext } from '../../types/data/Service';
 
 export default class ResolverBase {
     // MEMBER DATA

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

@@ -2,16 +2,17 @@
 import ResolverBase from './ResolverBase';
 
 // TYPES
-import { TweetFilter } from '../types/Tweet';
-import { Cursor, DataContext } from '../types/Service';
-
-// HELPERS
-import { ValidationErrors } from '../types/graphql/Errors';
+import { TweetFilter } from '../../types/data/Tweet';
+import { Cursor, DataContext } from '../../types/data/Service';
+import { DataErrors, ValidationErrors } from '../../types/data/Errors';
 
 export default class TweetResolver extends ResolverBase {
+    // MEMBER DATA
+    private batchSize: number;                                              // To store the batch size while fetching data
     // MEMBER METHODS
     constructor(context: DataContext) {
         super(context);
+        this.batchSize = 20;
     }
     
     /**
@@ -29,14 +30,13 @@ export default class TweetResolver extends ResolverBase {
     /**
      * @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 count The number of tweets to fetch, must be >= 1
      * @param cursor The cursor to the batch of tweets to fetch
      */
-    async resolveTweets(filter: TweetFilter, count: number, cursor: string): Promise<any[]> {
+    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)) {
@@ -44,15 +44,15 @@ export default class TweetResolver extends ResolverBase {
         }
 
         // 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.tweets.getTweets(filter, count, next.value);
+            const res = await this.context.tweets.getTweets(filter, this.batchSize, next.value);
 
             // If data is available
             if (res.list?.length) {
@@ -69,6 +69,11 @@ export default class TweetResolver extends ResolverBase {
             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
@@ -80,7 +85,7 @@ export default class TweetResolver extends ResolverBase {
     /**
      * @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 count The number of quotes to be fetched, must be >= 1 (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
@@ -89,7 +94,7 @@ export default class TweetResolver extends ResolverBase {
         let quotes: any[] = [];                                                     // To store the list of quotes
 
         // If all tweets are to be fetched
-        count = (all || count > quoteCount) ? quoteCount : count;
+        count = all ? quoteCount : count;
 
         // Preparing the filter to use
         let filter = {
@@ -112,30 +117,29 @@ export default class TweetResolver extends ResolverBase {
     /**
      * @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 count The total number of likers to fetch, must be >= 10 (when no cursor if 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[]> {
+    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;
+        count = all ? likesCount : 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 likers
-            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.tweets.getTweetLikers(id, count, next.value);
+            const res = await this.context.tweets.getTweetLikers(id, this.batchSize, next.value);
 
             // If data is available
             if (res.list?.length) {
@@ -152,6 +156,11 @@ export default class TweetResolver extends ResolverBase {
             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
@@ -163,30 +172,29 @@ export default class TweetResolver extends ResolverBase {
     /**
      * @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 count The total number of retweeters to fetch, must be >= 10 (when no cursor if 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[]> {
+    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;
+        count = all ? retweetsCount : 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 retweeters
-            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.tweets.getTweetRetweeters(id, count, next.value);
+            const res = await this.context.tweets.getTweetRetweeters(id, this.batchSize, next.value);
 
             // If data is available
             if (res.list?.length) {
@@ -203,6 +211,11 @@ export default class TweetResolver extends ResolverBase {
             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

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