rettiwt-api 1.1.2 → 1.1.5

package/src/models/data/Tweet.ts

@@ -0,0 +1,118 @@
+// TYPES
+import { ITweet, ITweetEntities } from '../../types/Tweet';
+import { Result as RawTweet, Entities2 as RawTweetEntities } from '../../types/raw/tweet/Tweet';
+
+// PARSERS
+import * as Parsers from '../../services/helper/Parser';
+
+/**
+ * The different types parsed entities like urls, media, mentions, hashtags, etc.
+ * 
+ * @internal
+ */
+export class TweetEntities implements ITweetEntities {
+    // MEMBER DATA
+    /** The list of hashtags mentioned in the tweet. */
+    hashtags: string[] = [];
+
+    /** The list of urls mentioned in the tweet. */
+    urls: string[] = [];
+
+    /** The list of IDs of users mentioned in the tweet. */
+    mentionedUsers: string[] = [];
+
+    /** The list of urls to various media mentioned in the tweet. */
+    media: string[] = [];
+
+    // MEMBER METHODS
+    constructor(entities: RawTweetEntities) {
+        // Extracting user mentions
+        if (entities.user_mentions) {
+            for (let user of entities.user_mentions) {
+                this.mentionedUsers.push(user.id_str);
+            }
+        }
+
+        // Extracting urls
+        if (entities.urls) {
+            for (let url of entities.urls) {
+                this.urls.push(url.expanded_url);
+            }
+        }
+
+        // Extracting hashtags
+        if (entities.hashtags) {
+            for (let hashtag of entities.hashtags) {
+                this.hashtags.push(hashtag.text);
+            }
+        }
+
+        // Extracting media urls (if any)
+        if (entities.media) {
+            for (const media of entities.media) {
+                this.media.push(media.media_url_https);
+            }
+        }
+    }
+}
+
+/**
+ * The details of a single Tweet.
+ * 
+ * @internal
+ */
+export class Tweet implements ITweet {
+    /** The rest id of the tweet. */
+    id: string;
+
+    /** The rest id of the user who made the tweet. */
+    tweetBy: string;
+
+    /** The date and time of creation of the tweet, in UTC string format. */
+    createdAt: string;
+
+    /** Additional tweet entities like urls, mentions, etc. */
+    entities: TweetEntities;
+
+    /** The rest id of the tweet which is quoted in the tweet. */
+    quoted: string;
+
+    /** The full text content of the tweet. */
+    fullText: string;
+
+    /** The rest id of the user to which the tweet is a reply. */
+    replyTo: string;
+
+    /** The language in which the tweet is written. */
+    lang: string;
+
+    /** The number of quotes of the tweet. */
+    quoteCount: number;
+
+    /** The number of replies to the tweet. */
+    replyCount: number;
+
+    /** The number of retweets of the tweet. */
+    retweetCount: number;
+
+    /** The number of likes of the tweet. */
+    likeCount: number;
+
+    /**
+     * @param tweet The raw tweet data.
+     */
+    constructor(tweet: RawTweet) {
+        this.id = tweet.rest_id;
+        this.createdAt = tweet.legacy.created_at;
+        this.tweetBy = tweet.legacy.user_id_str;
+        this.entities = new TweetEntities(tweet.legacy.entities);
+        this.quoted = tweet.legacy.quoted_status_id_str;
+        this.fullText = Parsers.normalizeText(tweet.legacy.full_text);
+        this.replyTo = tweet.legacy.in_reply_to_status_id_str;
+        this.lang = tweet.legacy.lang;
+        this.quoteCount = tweet.legacy.quote_count;
+        this.replyCount = tweet.legacy.reply_count;
+        this.retweetCount = tweet.legacy.retweet_count;
+        this.likeCount = tweet.legacy.favorite_count;
+    }
+}

package/src/models/data/User.ts

@@ -0,0 +1,72 @@
+// TYPES
+import { IUser } from '../../types/User';
+import { Result as RawUser } from '../../types/raw/user/User';
+
+/**
+ * The details of a single user.
+ * 
+ * @internal
+ */
+export class User implements IUser {
+    /** The rest id of the user. */
+    id: string;
+
+    /** The username/screenname of the user. */
+    userName: string;
+
+    /** The full name of the user. */
+    fullName: string;
+
+    /** The creation date of user's account. */
+    createdAt: string;
+
+    /** The user's description. */
+    description: string;
+
+    /** Whether the account is verified or not. */
+    isVerified: boolean;
+
+    /** The number of tweets liked by the user. */
+    favouritesCount: number;
+
+    /** The number of followers of the user. */
+    followersCount: number;
+
+    /** The number of following of the user. */
+    followingsCount: number;
+
+    /** The number of tweets made by the user. */
+    statusesCount: number;
+
+    /** The location of user as provided by user. */
+    location: string;
+
+    /** The rest id of the tweet pinned in the user's profile. */
+    pinnedTweet: string;
+
+    /** The url of the profile banner image. */
+    profileBanner: string;
+
+    /** The url of the profile image. */
+    profileImage: string;
+
+    /**
+     * @param user The raw user data.
+     */
+    constructor(user: RawUser) {
+        this.id = user.rest_id;
+        this.userName = user.legacy.screen_name;
+        this.fullName = user.legacy.name;
+        this.createdAt = user.legacy.created_at;
+        this.description = user.legacy.description;
+        this.isVerified = user.legacy.verified;
+        this.favouritesCount = user.legacy.favourites_count;
+        this.followersCount = user.legacy.followers_count;
+        this.followingsCount = user.legacy.friends_count;
+        this.statusesCount = user.legacy.statuses_count;
+        this.location = user.legacy.location;
+        this.pinnedTweet = user.legacy.pinned_tweet_ids_str[0];
+        this.profileBanner = user.legacy.profile_banner_url;
+        this.profileImage = user.legacy.profile_image_url_https;
+    }
+}

package/src/models/errors/DataValidationError.ts

@@ -0,0 +1,29 @@
+// PACKAGES
+import { ValidationError } from "class-validator";
+
+/**
+ * Error when any fields of a JSON data fails to validate.
+ * 
+ * @internal
+ * 
+ * @param errorDetails The details of about the specific fields that failed to validate.
+ */
+export class DataValidationError implements Error {
+    /** The name of the error. */
+    name: string;
+
+    /** The user-friendly error message. */
+    message: string;
+
+    /** The error data. */
+    data: ValidationError[];
+
+    /**
+     * @param data The error details.
+     */
+    constructor(errorDetails: ValidationError[]) {
+        this.name = 'ValidationError';
+        this.message = 'One or more validation errors occured. Refer to data for details';
+        this.data = errorDetails;
+    }
+}

package/src/server.ts

@@ -2,12 +2,10 @@
 import express from 'express';
 import { graphqlHTTP } from 'express-graphql';
 import { GraphQLSchema } from 'graphql';
+import 'reflect-metadata';
 
-// Services
-import { UserService } from './services/data/UserService';
-import { TweetService } from './services/data/TweetService';
-import { AccountService } from './services/accounts/AccountService';
-import { AuthService } from './services/AuthService';
+// SERVICES
+import { Rettiwt } from '.';
 
 // SCHEMA
 import { rootQuery } from './graphql/queries/RootQuery';
@@ -23,11 +21,12 @@ app.use('/graphql', graphqlHTTP(req => ({
     schema: new GraphQLSchema({
         query: rootQuery
     }),
-    context: {
-        users: new UserService(new AuthService(req.headers.cookie as string)),
-        tweets: new TweetService(new AuthService(req.headers.cookie as string)),
-        account: new AccountService()
-    },
+    context: Rettiwt({
+        auth_token: req.headers['auth_token'] as string,
+        ct0: req.headers['ct0'] as string,
+        kdt: req.headers['kdt'] as string,
+        twid: req.headers['twid'] as string,
+    }),
     // If app is running in development environment, enable graphiql
     graphiql: config.is_development
 })));

package/src/services/{accounts → auth}/AccountService.ts

@@ -2,15 +2,17 @@
 import { curly, CurlyResult } from 'node-libcurl';
 
 // SERVICES
-import { AuthService } from '../AuthService';
+import { AuthService } from './AuthService';
 
 // TYPES
-import { GuestCredentials } from '../../types/Authentication';
-import { HttpStatus } from '../../types/HTTP';
-import { AuthenticationErrors } from '../../types/data/Errors';
+import { IGuestCredentials, IAuthCookie } from '../../types/Authentication';
+
+// ENUMS
+import { HttpStatus } from '../../enums/HTTP';
+import { AuthenticationErrors } from '../../enums/Errors';
 
 // HELPERS
-import LoginFlows from './LoginFlows';
+import LoginFlows from '../helper/payloads/LoginFlows';
 import { loginHeader } from '../helper/Headers';
 import { Cookie, CookieJar } from 'cookiejar';
 
@@ -19,12 +21,11 @@ import { Cookie, CookieJar } from 'cookiejar';
  * @public
  */
 export class AccountService {
-    // MEMBER DATA
     /** The AuthService instance to use for authentication. */
     private auth: AuthService;
     
     /** The current guest credentials to use. */
-    private guestCreds: GuestCredentials;
+    private guestCreds: IGuestCredentials;
 
     /** The cookies received from Twitter after logging in. */
     private cookies: Cookie[];
@@ -32,7 +33,6 @@ export class AccountService {
     /** The flow token received after execution of current flow. */
     private flowToken: string;
 
-    // MEMBER METHODS
     constructor() {
         this.auth = new AuthService();
         this.guestCreds = { authToken: '', guestToken: '' };
@@ -43,7 +43,7 @@ export class AccountService {
     /**
      * @returns The current guest credentials to use. If if does not exists, then a new one is created
      */
-    private async getGuestCredentials(): Promise<GuestCredentials> {
+    private async getGuestCredentials(): Promise<IGuestCredentials> {
         // If a guest credential has not been already set, get a new one
         if (!this.guestCreds.guestToken) {
             this.guestCreds = await this.auth.getGuestCredentials();
@@ -176,15 +176,15 @@ export class AccountService {
     }
 
     /**
-     * Login to Twitter using the given credentials and get back the cookies.
-     * @public
+     * Execute all the flows required to login to Twitter, using the given credentials, then set the response cookies.
+     * 
+     * @internal
      * 
-     * @param email The email of the account to be logged into
-     * @param userName The username associated with the given account
-     * @param password The password to the account
-     * @returns The cookies for authenticating with the given account
+     * @param email The email of the account to be logged into.
+     * @param userName The username associated with the given account.
+     * @param password The password to the account.
      */
-    public async login(email: string, userName: string, password: string): Promise<string> {
+    private async executeLoginFlows(email: string, userName: string, password: string): Promise<void> {
         /**
          * This works by sending a chain of request that are required for login to twitter.
          * Each method in the chain returns a flow token that must be provied as payload in the next method in the chain.
@@ -197,9 +197,61 @@ export class AccountService {
         await this.enterUserIdentifier(email);
         await this.enterAlternateUserIdentifier(userName);
         await this.enterPassword(password);
-        await this.accountDuplicationCheck();
+        await this.accountDuplicationCheck(); 
+    }
+
+    /**
+     * Parse the authentication cookies recieved from Twitter into known format.
+     * 
+     * @internal
+     * 
+     * @param cookies The raw cookies received from Twitter.
+     * 
+     * @returns The parsed cookies of type {@link AuthCookie}
+     */
+    private parseCookies(cookies: Cookie[]): IAuthCookie {
+        /** The tempoorary parsed cookies. */
+        let tempCookies: any = {};
+        
+        /**
+         * Parsing the cookies into a standard JSON format.
+         * The format is 'cookie_name': 'cookie_value'.
+         * All other cookie parameters like expiry, etc are dropped.
+         */
+        cookies.forEach(cookie => {
+            tempCookies[cookie.name] = cookie.value;
+        });
+
+        return {
+            kdt: tempCookies['kdt'],
+            twid: tempCookies['twid'],
+            ct0: tempCookies['ct0'],
+            auth_token: tempCookies['auth_token']
+        };
+    }
+
+    /**
+     * Login to Twitter using the given credentials and get back the cookies.
+     * 
+     * @public
+     * 
+     * @param email The email of the account to be logged into.
+     * @param userName The username associated with the given account.
+     * @param password The password to the account.
+     * 
+     * @returns The cookies for authenticating with the given account.
+     */
+    public async login(email: string, userName: string, password: string): Promise<IAuthCookie> {
+        /** The parsed cookies that will be returned. */
+        let parsedCookies: IAuthCookie;
+        
+        // Executing all login flows
+        await this.executeLoginFlows(email, userName, password);
+
+        // Parsing the cookies
+        parsedCookies = this.parseCookies(this.cookies);
         
-        // Returning the final cookies
-        return this.cookies.join(';');
+        // Returning the final parsed cookies
+        return parsedCookies;
     }
 }

package/src/services/auth/AuthService.ts

@@ -0,0 +1,81 @@
+// PACKAGE
+import axios from 'axios';
+
+// URLS
+import { guestTokenUrl } from '../helper/urls/Authentication';
+
+// MODELS
+import { AuthCookie } from '../../models/auth/AuthCookie';
+
+// TYPES
+import { IGuestCredentials, IAuthCredentials } from '../../types/Authentication';
+
+// CONFIGS
+import { config } from '../../config/env';
+
+/**
+ * Handles authentication of http requests and other authentication related tasks.
+ * 
+ * @internal
+ */
+export class AuthService {
+    /** The common bearer token for authentication. */
+    private authToken: string;
+
+    /** The current authentication credentials. */
+    private credentials: IAuthCredentials;
+
+    /** Whether instance has been authenticated or not. */
+    public isAuthenticated: boolean;
+
+    /**
+     * @param cookie The cookie to be used for authenticating.
+     * 
+     * @remarks
+     * 
+     * If no cookie is supplied, then guest authentication is used.
+     */
+    constructor(cookie?: AuthCookie) {
+        // Reading the auth token from the config, since it's always the same
+        this.authToken = config.twitter_auth_token;
+
+        // Setting authentication status
+        this.isAuthenticated = (cookie?.auth_token && cookie?.ct0 && cookie?.kdt && cookie?.twid) ? true : false;
+
+        // If a cookies is supplied, initializing authenticated credentials
+        if (this.isAuthenticated) {
+            // Converting the cookie from JSON to object
+            cookie = new AuthCookie(cookie);
+
+            // Setting up the authenticated credentials
+            this.credentials = { authToken: this.authToken, csrfToken: cookie.ct0, cookie: cookie.toString() };
+        }
+        // If no cookie has been supplied, initializing empty credentials
+        else {
+            // Setting up the authenticated credentials
+            this.credentials = { authToken: this.authToken, csrfToken: '', cookie: '' };
+        }
+    }
+    
+    /**
+     * @returns The current authentication credentials. A different credential is returned each time this is invoked
+     */
+    async getAuthCredentials(): Promise<IAuthCredentials> {
+        return this.credentials;
+    }
+
+    /**
+     * @returns The guest credentials fetched from twitter.
+     */
+    async getGuestCredentials(): Promise<IGuestCredentials> {
+        // 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
+        }));
+    }
+}