rettiwt-api 1.1.1 → 1.1.5

package/src/graphql/resolvers/TweetResolver.ts

@@ -2,17 +2,18 @@
 import ResolverBase from './ResolverBase';
 
 // TYPES
-import { TweetFilter } from '../../types/data/Tweet';
-import { Cursor, DataContext } from '../../types/data/Service';
-import { DataErrors, ValidationErrors } from '../../types/data/Errors';
+import { IDataContext } from '../../types/Rettiwt'
+import { TweetFilter } from '../../models/args/TweetFilter';
+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: DataContext) {
+    constructor(context: IDataContext) {
         super(context);
-        this.batchSize = 20;
+        this.batchSize = 100;
     }
     
     /**
@@ -21,7 +22,9 @@ export default class TweetResolver extends ResolverBase {
      */
     async resolveTweet(id: string): Promise<any> {
         // Getting the data
-        let res = await this.context.tweets.getTweetById(id);
+        let res = await this.context.tweets.getTweetDetails(id).catch(error => {
+            throw this.getGraphQLError(error);
+        });
 
         // Evaluating response
         return res;
@@ -37,22 +40,22 @@ export default class TweetResolver extends ResolverBase {
         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
-
-        // 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);
-        }
+        
+        /** 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
-        this.batchSize = (count < this.batchSize) ? count : this.batchSize;
+        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
-            this.batchSize = ((count - total) < this.batchSize) ? (count - total) : this.batchSize;
+            batchSize = ((count - total) < batchSize) ? (count - total) : batchSize;
 
             // Getting the data
-            const res = await this.context.tweets.getTweets(filter, this.batchSize, next.value);
+            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) {
@@ -109,7 +112,9 @@ export default class TweetResolver extends ResolverBase {
         };
 
         // Fetching the quotes using resolveTweets method
-        quotes = await this.resolveTweets(filter, count, cursor);
+        quotes = await this.resolveTweets(filter, count, cursor).catch(error => {
+            throw this.getGraphQLError(error);
+        });
 
         return quotes;
     }
@@ -139,7 +144,9 @@ export default class TweetResolver extends ResolverBase {
             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);
+            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) {
@@ -194,7 +201,9 @@ export default class TweetResolver extends ResolverBase {
             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);
+            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) {

package/src/graphql/resolvers/UserResolver.ts

@@ -2,15 +2,16 @@
 import ResolverBase from './ResolverBase';
 
 // TYPES
-import { Cursor, DataContext } from '../../types/data/Service';
-import { DataErrors, ValidationErrors } from '../../types/data/Errors';
+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: DataContext) {
+    constructor(context: IDataContext) {
         super(context);
         this.batchSize = 40;
     }
@@ -18,21 +19,12 @@ export default class UserResolver extends ResolverBase {
     /**
      * @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
+     * @param id The id/username 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.getUserDetails(userName);
-        }
-        // If id is supplied
-        else if (id) {
-            return await this.context.users.getUserDetailsById(id);
-        }
-        // If neither userName nor id is supplied
-        else {
-            throw new Error(ValidationErrors.NoUserIdentification);
-        }
+    async resolveUserDetails(id: string): Promise<any> {
+        return await this.context.users.getUserDetails(id).catch(error => {
+            throw this.getGraphQLError(error);
+        });
     }
 
     /**
@@ -60,7 +52,9 @@ export default class UserResolver extends ResolverBase {
             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);
+            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) {
@@ -115,7 +109,9 @@ export default class UserResolver extends ResolverBase {
             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);
+            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) {
@@ -170,7 +166,9 @@ export default class UserResolver extends ResolverBase {
             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);
+            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) {

package/src/graphql/types/TweetTypes.ts

@@ -17,7 +17,7 @@ export const TweetTokens: GraphQLObjectType = new GraphQLObjectType({
         urls: { type: new GraphQLList(GraphQLString) },
         mentionedUsers: {
             type: UserList,
-            resolve: (parent, args, context) => parent.mentionedUsers.map((user: string) => new UserResolver(context).resolveUserDetails('', user))
+            resolve: (parent, args, context) => parent.mentionedUsers.map((user: string) => new UserResolver(context).resolveUserDetails(user))
         },
         media: { type: new GraphQLList(GraphQLString) },
     })
@@ -30,7 +30,7 @@ export const Tweet: GraphQLObjectType = new GraphQLObjectType({
         id: { type: GraphQLString },
         tweetBy: {
             type: User,
-            resolve: (parent, args, context) => new UserResolver(context).resolveUserDetails('', parent.tweetBy)
+            resolve: (parent, args, context) => new UserResolver(context).resolveUserDetails(parent.tweetBy)
         },
         createdAt: { type: GraphQLString },
         entities: { type: TweetTokens },

package/src/graphql/types/UserTypes.ts

@@ -4,7 +4,7 @@ import { GraphQLBoolean, GraphQLObjectType, GraphQLString, GraphQLInt, GraphQLLi
 // TYPES
 import { Tweet, TweetList } from './TweetTypes'
 import { Cursor } from './Global';
-import { TweetFilter } from '../../types/data/Tweet';
+import { TweetFilter } from '../../models/args/TweetFilter';
 
 // RESOLVERS
 import UserResolver from '../resolvers/UserResolver';

package/src/index.ts

@@ -1,18 +1,30 @@
+// PACKAGES
+import 'reflect-metadata';
+
 // SERVICES
-import { AuthService } from "./services/AuthService";
+import { AuthService } from "./services/auth/AuthService";
 import { UserService } from "./services/data/UserService";
 import { TweetService } from "./services/data/TweetService";
-import { AccountService } from "./services/accounts/AccountService";
+import { AccountService } from "./services/auth/AccountService";
+
+// TYPES
+import { IAuthCookie } from './types/Authentication';
 
 /**
- * @param cookie The cookie string to use to fetch data
- * @returns The API for fetching user and tweet data
+ * The instance for fetching data from Twitter.
+ * 
+ * @public
+ * 
+ * @param cookie The cookie to use to fetch data.
+ * 
+ * @returns The API for fetching user and tweet data.
+ * 
  * @remarks The cookie can be obtained by using {@link AccountService.login} method.
- * To use the {@link AccountService.login} method, create a {@link Rettiwt} instance without passing any cookie string.
+ * To use the {@link AccountService.login} method, create a {@link Rettiwt} instance without passing any cookie .
  * Then use the {@link AccountService.login} method of {@link AccountService} to get the cookie.
  */
-export const Rettiwt = (cookie: string = '') => {
-    // Creating new auth service instance using the given cookie string
+export const Rettiwt = (cookie?: IAuthCookie) => {
+    // Creating new auth service instance using the given cookie
     const auth: AuthService = new AuthService(cookie);
 
     // Using the auth service instance to create data services instances
@@ -24,17 +36,27 @@ export const Rettiwt = (cookie: string = '') => {
 }
 
 // Exporting classes
-export * from './services/AuthService';
-export * from './services/CacheService';
-export * from './services/FetcherService';
-export * from './services/accounts/AccountService';
+export * from './services/auth/AuthService';
+export * from './services/auth/AccountService';
 export * from './services/data/TweetService';
 export * from './services/data/UserService';
+export * from './services/util/CacheService';
+export * from './services/util/FetcherService';
 
 // Exporting types
-export * from './types/data/Errors';
-export * from './types/data/Service';
-export * from './types/data/Tweet';
-export * from './types/data/User';
-export * from './types/Authentication';
-export * from './types/HTTP';
+export * from './types/Args';
+export { IAuthCookie } from './types/Authentication';
+export * from './types/Rettiwt';
+export * from './types/Service';
+export * from './types/Tweet';
+export * from './types/User';
+
+// Exporting models
+export * from './models/args/TweetFilter';
+export * from './models/args/TweetListArgs';
+export * from './models/args/UserListArgs';
+export * from './models/auth/AuthCookie';
+export * from './models/data/CursoredData';
+export * from './models/data/Tweet';
+export * from './models/data/User';
+export * from './models/errors/DataValidationError';

package/src/models/args/TweetFilter.ts

@@ -0,0 +1,119 @@
+// PACKAGE
+import { IsArray, IsBoolean, IsNumberString, IsString, IsOptional, IsDateString, validateSync } from 'class-validator';
+
+// TYPES
+import { ITweetFilter } from '../../types/Args';
+import { DataValidationError } from '../errors/DataValidationError';
+
+/**
+ * The filter to be used for fetching tweets from Twitter.
+ * 
+ * @internal
+ */
+export class TweetFilter implements ITweetFilter {
+    /** The list of words to search. */
+    @IsArray()
+    @IsString({ each: true })
+    @IsOptional()
+    words?: string[];
+
+    /** The list of hashtags to search.
+     *
+     * @remarks
+     * '#' must be excluded from the hashtag!
+     */
+    @IsArray()
+    @IsString({ each: true })
+    @IsOptional()
+    hashtags?: string[];
+
+    /** The list of usernames whose tweets are to be searched.
+     *
+     * @remarks
+     * '@' must be excluded from the username!
+     */
+    @IsArray()
+    @IsString({ each: true })
+    @IsOptional()
+    fromUsers?: string[];
+
+    /** The list of username to whom the tweets to be searched, are adressed.
+     *
+     * @remarks
+     * '@' must be excluded from the username!
+     */
+    @IsArray()
+    @IsString({ each: true })
+    @IsOptional()
+    toUsers?: string[];
+
+    /** The list of username mentioned in the tweets to search.
+     *
+     * @remarks
+     * '@' must be excluded from the username!
+     */
+    @IsArray()
+    @IsString({ each: true })
+    @IsOptional()
+    mentions?: string[];
+
+    /** The date starting from which tweets are to be searched.
+     *
+     * @remarks
+     * Must be in the format YYYY-MM-DD.
+     */
+    @IsOptional()
+    @IsDateString()
+    startDate?: string;
+
+    /** The date upto which tweets are to be searched.
+     *
+     * @remarks
+     * Must be in the format YYYY-MM-DD.
+     */
+    @IsOptional()
+    @IsDateString()
+    endDate?: string;
+
+    /** The id of the tweet, after which the tweets are to be searched. */
+    @IsNumberString()
+    @IsOptional()
+    sinceId?: string;
+
+    /** The id of the tweet which is quoted in the tweets to search. */
+    @IsNumberString()
+    @IsOptional()
+    quoted?: string;
+    
+    /** Whether to fetch tweets that are links or not.
+     *
+     * @defaultValue false
+     */
+    @IsBoolean()
+    @IsOptional()
+    links?: boolean;
+
+    /**
+     * @param filter The incoming filter in JSON format.
+     */
+    constructor(filter: TweetFilter) {
+        this.endDate = filter.endDate;
+        this.fromUsers = filter.fromUsers;
+        this.hashtags = filter.hashtags;
+        this.links = filter.links;
+        this.mentions = filter.mentions;
+        this.quoted = filter.quoted;
+        this.sinceId = filter.sinceId;
+        this.startDate = filter.startDate;
+        this.toUsers = filter.toUsers;
+        this.words = filter.words;
+
+        // Validating the filter
+        const validationResult = validateSync(this);
+
+        // If valiation error occured
+        if (validationResult.length) {
+            throw new DataValidationError(validationResult);
+        }
+    }
+}

package/src/models/args/TweetListArgs.ts

@@ -0,0 +1,47 @@
+// PACKAGES
+import { IsInt, IsString, IsOptional, Min, validateSync, Max, ValidateIf } from 'class-validator';
+
+// TYPES
+import { IListArgs } from '../../types/Args';
+import { DataValidationError } from '../errors/DataValidationError';
+
+/**
+ * The arguments for fetching cursored list in TweetService.
+ * 
+ * @internal
+ */
+export class TweetListArgs implements IListArgs {
+    /** The number of data items to fetch.
+     * 
+     * @defaultValue 10
+     * @remarks Must be >= 10 and <= 100
+     */
+    @IsInt()
+    @IsOptional()
+    @Max(100)
+    @ValidateIf(ob => ob.cursor.length == 0)
+    @Min(10)    
+    count: number;
+
+    /** The cursor to the batch of data to fetch. */
+    @IsString()
+    @IsOptional()
+    cursor: string;
+
+    /**
+     * @param count The number of data items to fetch.
+     * @param cursor The cursor to the batch of data to fetch.
+     */
+    constructor(count: number = 10, cursor: string = '') {
+        this.count = count;
+        this.cursor = cursor;
+
+        // Validating the arguments
+        const validationResult = validateSync(this);
+
+        // If valiation error occured
+        if (validationResult.length) {
+            throw new DataValidationError(validationResult);
+        }
+    }
+}

package/src/models/args/UserListArgs.ts

@@ -0,0 +1,47 @@
+// PACKAGES
+import { IsInt, IsString, IsOptional, Min, validateSync, Max, ValidateIf } from 'class-validator';
+
+// TYPES
+import { IListArgs } from '../../types/Args';
+import { DataValidationError } from '../errors/DataValidationError';
+
+/**
+ * The arguments for fetching cursored list in TweetService.
+ * 
+ * @internal
+ */
+export class UserListArgs implements IListArgs {
+    /** The number of data items to fetch.
+     * 
+     * @defaultValue 40
+     * @remarks Must be >= 40 and <= 100
+     */
+    @IsInt()
+    @IsOptional()
+    @Max(100)
+    @ValidateIf(ob => ob.cursor.length == 0)
+    @Min(40)
+    count: number;
+
+    /** The cursor to the batch of data to fetch. */
+    @IsString()
+    @IsOptional()
+    cursor: string;
+
+    /**
+     * @param count The number of data items to fetch.
+     * @param cursor The cursor to the batch of data to fetch.
+     */
+    constructor(count: number = 40, cursor: string = '') {
+        this.count = count;
+        this.cursor = cursor;
+
+        // Validating the arguments
+        const validationResult = validateSync(this);
+
+        // If valiation error occured
+        if (validationResult.length) {
+            throw new DataValidationError(validationResult);
+        }
+    }
+}

package/src/models/auth/AuthCookie.ts

@@ -0,0 +1,43 @@
+// TYPES
+import { IAuthCookie } from '../../types/Authentication';
+
+/**
+ * The cookie containing the tokens that are used to authenticate against Twitter.
+ * 
+ * @internal
+ */
+export class AuthCookie implements IAuthCookie {
+    /** Token used to authenticate a device. */
+    kdt: string;
+
+    /** Token used to authenticate a user using a Twitter ID. */
+    twid: string;
+
+    /** The CSRF token of the session. */
+    ct0: string;
+
+    /** The authentication token used while logging in to the account. */
+    auth_token: string;
+
+    constructor(cookie?: IAuthCookie) {
+        this.auth_token = cookie?.auth_token ?? '';
+        this.ct0 = cookie?.ct0 ?? '';
+        this.kdt = cookie?.kdt ?? '';
+        this.twid = cookie?.twid ?? '';
+    }
+
+    /**
+     * @returns The string respresentation of this cookie in the valid cookie string format.
+     */
+    toString(): string {
+        /** The string representation of this cookie. */
+        let cookieString: string = '';
+        
+        // Iterating through the (key, value) pairs of this cookie
+        for (let [key, value] of Object.entries(this)) {
+            cookieString += `${key}=${value};`;
+        }
+
+        return cookieString;
+    }
+}

package/src/models/data/CursoredData.ts

@@ -0,0 +1,45 @@
+// TYPES
+import { ICursor,ICursoredData } from "../../types/Service";
+
+/**
+ * The cursor to the batch of data to be fetched.
+ * 
+ * @internal
+ */
+export class Cursor implements ICursor {
+    /** The cursor string. */
+    value: string;
+
+    /**
+     * Initializes a new cursor from the given cursor string.
+     * 
+     * @param cursorStr The string representation of the cursor.
+     */
+    constructor(cursorStr: string) {
+        this.value = cursorStr;
+    }
+}
+
+/**
+ * The data that us fetched batch-wise along with a cursor.
+ * 
+ * @internal
+ * 
+ * @typeParam Type - The type of data present in the list.
+ */
+export class CursoredData<T> implements ICursoredData<T> {
+    /** The list of data of the given type. */
+    list: T[];
+
+    /** The cursor to the next batch of data. */
+    next: Cursor;
+
+    /**
+     * @param list The list of data item to store.
+     * @param next The cursor to the next batch of data.
+     */
+    constructor(list: T[] = [], next: string = '') {
+        this.list = list;
+        this.next = new Cursor(next);
+    }
+}