rettiwt-api 1.0.1

package/dist/types/raw/user/Tweets.js

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

package/dist/types/raw/user/Tweets.js.map

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

package/dist/types/raw/user/User.d.ts

@@ -0,0 +1,117 @@
+export default interface Root {
+    data: Data;
+}
+export interface Data {
+    user: User;
+}
+export interface User {
+    result: Result;
+}
+export interface Result {
+    __typename: string;
+    id: string;
+    rest_id: string;
+    affiliates_highlighted_label: AffiliatesHighlightedLabel;
+    has_nft_avatar: boolean;
+    legacy: Legacy;
+    smart_blocked_by: boolean;
+    smart_blocking: boolean;
+    super_follow_eligible: boolean;
+    super_followed_by: boolean;
+    super_following: boolean;
+    legacy_extended_profile: LegacyExtendedProfile;
+    is_profile_translatable: boolean;
+}
+export interface AffiliatesHighlightedLabel {
+}
+export interface Legacy {
+    blocked_by: boolean;
+    blocking: boolean;
+    can_dm: boolean;
+    can_media_tag: boolean;
+    created_at: string;
+    default_profile: boolean;
+    default_profile_image: boolean;
+    description: string;
+    entities: Entities;
+    fast_followers_count: number;
+    favourites_count: number;
+    follow_request_sent: boolean;
+    followed_by: boolean;
+    followers_count: number;
+    following: boolean;
+    friends_count: number;
+    has_custom_timelines: boolean;
+    is_translator: boolean;
+    listed_count: number;
+    location: string;
+    media_count: number;
+    muting: boolean;
+    name: string;
+    normal_followers_count: number;
+    notifications: boolean;
+    pinned_tweet_ids_str: any[];
+    possibly_sensitive: boolean;
+    profile_banner_extensions: ProfileBannerExtensions;
+    profile_banner_url: string;
+    profile_image_extensions: ProfileImageExtensions;
+    profile_image_url_https: string;
+    profile_interstitial_type: string;
+    protected: boolean;
+    screen_name: string;
+    statuses_count: number;
+    translator_type: string;
+    verified: boolean;
+    want_retweets: boolean;
+    withheld_in_countries: any[];
+}
+export interface Entities {
+    description: Description;
+}
+export interface Description {
+    urls: any[];
+}
+export interface ProfileBannerExtensions {
+    mediaColor: MediaColor;
+}
+export interface MediaColor {
+    r: R;
+}
+export interface R {
+    ok: Ok;
+}
+export interface Ok {
+    palette: Palette[];
+}
+export interface Palette {
+    percentage: number;
+    rgb: Rgb;
+}
+export interface Rgb {
+    blue: number;
+    green: number;
+    red: number;
+}
+export interface ProfileImageExtensions {
+    mediaColor: MediaColor2;
+}
+export interface MediaColor2 {
+    r: R2;
+}
+export interface R2 {
+    ok: Ok2;
+}
+export interface Ok2 {
+    palette: Palette2[];
+}
+export interface Palette2 {
+    percentage: number;
+    rgb: Rgb2;
+}
+export interface Rgb2 {
+    blue: number;
+    green: number;
+    red: number;
+}
+export interface LegacyExtendedProfile {
+}

package/dist/types/raw/user/User.js

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

package/dist/types/raw/user/User.js.map

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

package/dist/types/raw/user/Users.d.ts

@@ -0,0 +1,120 @@
+export default interface Root {
+    data: Data;
+}
+export interface Data {
+    users: User[];
+}
+export interface User {
+    result: Result;
+}
+export interface Result {
+    __typename: string;
+    id: string;
+    rest_id: string;
+    affiliates_highlighted_label: AffiliatesHighlightedLabel;
+    has_graduated_access: boolean;
+    has_nft_avatar: boolean;
+    is_blue_verified: boolean;
+    legacy: Legacy;
+    smart_blocked_by: boolean;
+    smart_blocking: boolean;
+    super_follow_eligible: boolean;
+    super_followed_by: boolean;
+    super_following: boolean;
+    verified_phone_status: boolean;
+    legacy_extended_profile: LegacyExtendedProfile;
+    is_profile_translatable: boolean;
+}
+export interface AffiliatesHighlightedLabel {
+}
+export interface Legacy {
+    blocked_by: boolean;
+    blocking: boolean;
+    can_dm: boolean;
+    can_media_tag: boolean;
+    created_at: string;
+    default_profile: boolean;
+    default_profile_image: boolean;
+    description: string;
+    entities: Entities;
+    fast_followers_count: number;
+    favourites_count: number;
+    follow_request_sent: boolean;
+    followed_by: boolean;
+    followers_count: number;
+    following: boolean;
+    friends_count: number;
+    has_custom_timelines: boolean;
+    is_translator: boolean;
+    listed_count: number;
+    location: string;
+    media_count: number;
+    muting: boolean;
+    name: string;
+    normal_followers_count: number;
+    notifications: boolean;
+    pinned_tweet_ids_str: string[];
+    possibly_sensitive: boolean;
+    profile_banner_extensions: ProfileBannerExtensions;
+    profile_banner_url: string;
+    profile_image_extensions: ProfileImageExtensions;
+    profile_image_url_https: string;
+    profile_interstitial_type: string;
+    protected: boolean;
+    screen_name: string;
+    statuses_count: number;
+    translator_type: string;
+    verified: boolean;
+    want_retweets: boolean;
+    withheld_in_countries: any[];
+}
+export interface Entities {
+    description: Description;
+}
+export interface Description {
+    urls: any[];
+}
+export interface ProfileBannerExtensions {
+    mediaColor: MediaColor;
+}
+export interface MediaColor {
+    r: R;
+}
+export interface R {
+    ok: Ok;
+}
+export interface Ok {
+    palette: Palette[];
+}
+export interface Palette {
+    percentage: number;
+    rgb: Rgb;
+}
+export interface Rgb {
+    blue: number;
+    green: number;
+    red: number;
+}
+export interface ProfileImageExtensions {
+    mediaColor: MediaColor2;
+}
+export interface MediaColor2 {
+    r: R2;
+}
+export interface R2 {
+    ok: Ok2;
+}
+export interface Ok2 {
+    palette: Palette2[];
+}
+export interface Palette2 {
+    percentage: number;
+    rgb: Rgb2;
+}
+export interface Rgb2 {
+    blue: number;
+    green: number;
+    red: number;
+}
+export interface LegacyExtendedProfile {
+}

package/dist/types/raw/user/Users.js

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

package/dist/types/raw/user/Users.js.map

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

package/environment.d.ts

@@ -0,0 +1,11 @@
+// Declaring the environment variables
+declare global {
+    namespace NodeJS {
+        interface ProcessEnv {
+            DEVELOPMENT: string;                                // To store whether environment is production or development
+            APP_PORT: string                                    // To store the port on which this app runs
+        }
+    }
+}
+
+export {};

package/package.json

@@ -0,0 +1,40 @@
+{
+	"name": "rettiwt-api",
+	"version": "1.0.1",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"description": "An API for fetching data from TwitterAPI, without any rate limits!",
+	"scripts": {
+		"build": "tsc",
+		"start": "node ./dist/server.js",
+		"debug": "nodemon ./dist/server.js --inspect=0.0.0.0:9229"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/Rishikant181/twitter-api.git"
+	},
+	"author": {
+		"email": "rishikantsahu181@gmail.com",
+		"name": "Rishikant Sahu"
+	},
+	"license": "ISC",
+	"bugs": {
+		"url": "https://github.com/Rishikant181/Rettiwt-API/issues"
+	},
+	"homepage": "https://github.com/Rishikant181/Rettiwt-API#readme",
+	"dependencies": {
+		"axios": "^1.3.2",
+		"express": "^4.18.2",
+		"express-graphql": "0.12.0",
+		"graphql": "14.7.0",
+		"node-cache": "5.1.2",
+		"node-libcurl": "3.0.0"
+	},
+	"devDependencies": {
+		"@types/express": "4.17.13",
+		"@types/graphql": "14.5.0",
+		"@types/node": "17.0.24",
+		"nodemon": "2.0.20",
+		"typescript": "4.6.4"
+	}
+}

package/src/config/env.ts

@@ -0,0 +1,5 @@
+export const config = {
+    port: Number(process.env.APP_PORT),
+    is_development: (process.env.DEVELOPMENT == 'true'),
+    twitter_auth_token: 'Bearer AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA'
+}

package/src/index.ts

@@ -0,0 +1,19 @@
+// SERVICES
+import { AuthService } from "./services/AuthService";
+import { UserAccountService } from "./services/data/UserAccountService";
+import { TweetService } from "./services/data/TweetService";
+
+/**
+ * @param cookie The cookies string to use to fetch data
+ * @returns The API for fetching user and tweet data
+ */
+export const Rettiwt = (cookie: string = '') => {
+    // Creating new auth service instance using the given cookie string
+    const auth: AuthService = new AuthService(cookie);
+
+    // Using the auth service instance to create data services instances
+    return {
+        users: new UserAccountService(auth),
+        tweets: new TweetService(auth)
+    };
+}

package/src/models/graphql/Global.ts

@@ -0,0 +1,10 @@
+// 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/models/graphql/TweetTypes.ts

@@ -0,0 +1,154 @@
+// PACKAGE
+import { GraphQLList, GraphQLString, GraphQLObjectType, GraphQLInt, GraphQLBoolean, GraphQLUnionType } from "graphql";
+
+// TYPES
+import { User, UserList } from './UserTypes';
+import { Cursor } from './Global';
+
+// RESOLVERS
+import TweetResolver from '../../resolvers/TweetResolver';
+import UserResolver from "../../resolvers/UserResolver";
+
+//@ts-ignore
+export const TweetTokens = 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) },
+    })
+});
+
+//@ts-ignore
+export const Tweet = 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",
+                    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",
+                    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",
+                    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 },
+        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 = 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;
+        }
+    }
+}));

package/src/models/graphql/UserTypes.ts

@@ -0,0 +1,137 @@
+// PACKAGE
+import { GraphQLBoolean, GraphQLObjectType, GraphQLString, GraphQLInt, GraphQLList, GraphQLUnionType } from 'graphql';
+
+// TYPES
+import { Tweet, TweetList } from './TweetTypes'
+import { Cursor } from './Global';
+import { TweetFilter } from '../../types/Tweet';
+
+// RESOLVERS
+import UserResolver from '../../resolvers/UserResolver';
+import TweetResolver from '../../resolvers/TweetResolver';
+
+//@ts-ignore
+export const User = new GraphQLObjectType({
+    name: 'User',
+    description: 'The details of a single target twitter user',
+    fields: () => ({
+        id: { type: GraphQLString },
+        userName: { type: GraphQLString },
+        fullName: { type: GraphQLString },
+        createdAt: { type: GraphQLString },
+        description: { type: GraphQLString },
+        isVerified: { type: GraphQLBoolean },
+        location: { type: GraphQLString },
+        pinnedTweet: {
+            type: Tweet,
+            resolve: (parent, args, context) => (parent.pinnedTweet) ? new TweetResolver(context).resolveTweet(parent.pinnedTweet) : undefined
+        },
+        profileBanner: { type: GraphQLString },
+        profileImage: { type: GraphQLString },
+        favouritesCount: { type: GraphQLInt },
+        likes: {
+            type: TweetList,
+            args: {
+                count: {
+                    description: "The number of liked tweets to fetch",
+                    type: GraphQLInt,
+                    defaultValue: 10
+                },
+                all: {
+                    description: "Whether to fetch all tweets liked by user",
+                    type: GraphQLBoolean,
+                    defaultValue: false
+                },
+                cursor: {
+                    type: GraphQLString,
+                    description: 'The cursor to the batch of likes list to fetch',
+                    defaultValue: ''
+                }
+            },
+            resolve: (parent, args, context) => new UserResolver(context).resolveUserLikes(parent.id, args.count, args.all, args.cursor, parent.favouritesCount)
+        },
+        followersCount: { type: GraphQLInt },
+        followers: {
+            type: UserList,
+            args: {
+                count: {
+                    description: "The number of followers to fetch",
+                    type: GraphQLInt,
+                    defaultValue: 20
+                },
+                all: {
+                    description: "Whether to fetch all followers list",
+                    type: GraphQLBoolean,
+                    defaultValue: false
+                },
+                cursor: {
+                    type: GraphQLString,
+                    description: 'The cursor to the batch of followers list to fetch',
+                    defaultValue: ''
+                }
+            },
+            resolve: (parent, args, context) => new UserResolver(context).resolveUserFollowers(parent.id, args.count, args.all, args.cursor, parent.followersCount)
+        },
+        followingsCount: { type: GraphQLInt },
+        following: {
+            type: UserList,
+            args: {
+                count: {
+                    type: GraphQLInt,
+                    description: "The number of followings to fetch",
+                    defaultValue: 20
+                },
+                all: {
+                    description: "Whether to fetch all followings list",
+                    type: GraphQLBoolean,
+                    defaultValue: false
+                },
+                cursor: {
+                    type: GraphQLString,
+                    description: 'The cursor to the batch of followers list to fetch',
+                    defaultValue: ''
+                }
+            },
+            resolve: (parent, args, context) => new UserResolver(context).resolveUserFollowing(parent.id, args.count, args.all, args.cursor, parent.followingsCount)
+        },
+        statusesCount: { type: GraphQLInt },
+        tweets: {
+            type: TweetList,
+            args: {
+                count: {
+                    description: "The number of tweets to fetch",
+                    type: GraphQLInt,
+                    defaultValue: 10
+                },
+                all: {
+                    description: "Whether to fetch all tweets made by user",
+                    type: GraphQLBoolean,
+                    defaultValue: false
+                },
+                cursor: {
+                    type: GraphQLString,
+                    description: 'The cursor to the batch of tweets list to fetch',
+                    defaultValue: ''
+                }
+            },
+            resolve: (parent, args, context) => new TweetResolver(context).resolveTweets({ fromUsers: [parent.userName] } as TweetFilter, args.count, args.cursor)
+        }
+    })
+});
+
+//@ts-ignore
+export const UserList = new GraphQLList(new GraphQLUnionType({
+    name: 'UserCursorUnion',
+    description: 'A union type which can either be a User or a Cursor, used in cursored User lists',
+    types: [User, Cursor],
+    resolveType: (data) => {
+        // If it has a userName field => this is a User object
+        if(data.userName) {
+            return User;
+        }
+        // If it has a value field => this is a Cursor object
+        else if(data.value) {
+            return Cursor;
+        }
+    }
+}));