rettiwt-api 1.0.5 → 1.0.7

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

package/src/{models/graphql → graphql/types}/TweetTypes.ts

@@ -1,16 +1,15 @@
 // PACKAGE
-import { GraphQLList, GraphQLString, GraphQLObjectType, GraphQLInt, GraphQLBoolean, GraphQLUnionType } from "graphql";
+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";
+import TweetResolver from '../resolvers/TweetResolver';
+import UserResolver from "../resolvers/UserResolver";
 
-//@ts-ignore
-export const TweetTokens = new GraphQLObjectType({
+export const TweetTokens: GraphQLObjectType = new GraphQLObjectType({
     name: 'TweetTokens',
     description: 'Additional extracted tokens from the tweet like mentions, hashtags, etc',
     fields: () => ({
@@ -24,8 +23,7 @@ export const TweetTokens = new GraphQLObjectType({
     })
 });
 
-//@ts-ignore
-export const Tweet = new GraphQLObjectType({
+export const Tweet: GraphQLObjectType = new GraphQLObjectType({
     name: 'Tweet',
     description: 'The details of single tweet',
     fields: () => ({
@@ -52,7 +50,7 @@ export const Tweet = new GraphQLObjectType({
             args: {
                 count: {
                     type: GraphQLInt,
-                    description: "The number of quotes to fetch",
+                    description: "The number of quotes to fetch, must be >= 1",
                     defaultValue: 10
                 },
                 all: {
@@ -74,7 +72,7 @@ export const Tweet = new GraphQLObjectType({
             args: {
                 count: {
                     type: GraphQLInt,
-                    description: "The number of likers to fetch",
+                    description: "The number of likers to fetch, must be >= 10 (when no cursor if provided)",
                     defaultValue: 10
                 },
                 all: {
@@ -96,7 +94,7 @@ export const Tweet = new GraphQLObjectType({
             args: {
                 count: {
                     type: GraphQLInt,
-                    description: "The number of retweeters to fetch",
+                    description: "The number of retweeters to fetch, must be >= 10 (when no cursor if provided)",
                     defaultValue: 10
                 },
                 all: {
@@ -137,7 +135,7 @@ export const Tweet = new GraphQLObjectType({
     })
 });
 
-export const TweetList = new GraphQLList(new GraphQLUnionType({
+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],

package/src/{models/graphql → graphql/types}/UserTypes.ts

@@ -1,17 +1,16 @@
 // PACKAGE
-import { GraphQLBoolean, GraphQLObjectType, GraphQLString, GraphQLInt, GraphQLList, GraphQLUnionType } from 'graphql';
+import { GraphQLBoolean, GraphQLObjectType, GraphQLString, GraphQLInt, GraphQLList, GraphQLUnionType, GraphQLType } from 'graphql';
 
 // TYPES
 import { Tweet, TweetList } from './TweetTypes'
 import { Cursor } from './Global';
-import { TweetFilter } from '../../types/Tweet';
+import { TweetFilter } from '../../types/data/Tweet';
 
 // RESOLVERS
-import UserResolver from '../../resolvers/UserResolver';
-import TweetResolver from '../../resolvers/TweetResolver';
+import UserResolver from '../resolvers/UserResolver';
+import TweetResolver from '../resolvers/TweetResolver';
 
-//@ts-ignore
-export const User = new GraphQLObjectType({
+export const User: GraphQLObjectType = new GraphQLObjectType({
     name: 'User',
     description: 'The details of a single target twitter user',
     fields: () => ({
@@ -33,7 +32,7 @@ export const User = new GraphQLObjectType({
             type: TweetList,
             args: {
                 count: {
-                    description: "The number of liked tweets to fetch",
+                    description: "The number of liked tweets to fetch, must be >= 40 (when no cursor if provided)",
                     type: GraphQLInt,
                     defaultValue: 10
                 },
@@ -55,9 +54,9 @@ export const User = new GraphQLObjectType({
             type: UserList,
             args: {
                 count: {
-                    description: "The number of followers to fetch",
+                    description: "The number of followers to fetch, must be >= 40 (when no cursor is provided)",
                     type: GraphQLInt,
-                    defaultValue: 20
+                    defaultValue: 40
                 },
                 all: {
                     description: "Whether to fetch all followers list",
@@ -78,8 +77,8 @@ export const User = new GraphQLObjectType({
             args: {
                 count: {
                     type: GraphQLInt,
-                    description: "The number of followings to fetch",
-                    defaultValue: 20
+                    description: "The number of followings to fetch, must be >= 40 (when no cursor is provided)",
+                    defaultValue: 40
                 },
                 all: {
                     description: "Whether to fetch all followings list",
@@ -99,7 +98,7 @@ export const User = new GraphQLObjectType({
             type: TweetList,
             args: {
                 count: {
-                    description: "The number of tweets to fetch",
+                    description: "The number of tweets to fetch, must be >= 1",
                     type: GraphQLInt,
                     defaultValue: 10
                 },
@@ -114,13 +113,12 @@ export const User = new GraphQLObjectType({
                     defaultValue: ''
                 }
             },
-            resolve: (parent, args, context) => new TweetResolver(context).resolveTweets({ fromUsers: [parent.userName] } as TweetFilter, args.count, args.cursor)
+            resolve: (parent, args, context) => new TweetResolver(context).resolveTweets({ fromUsers: [parent.userName] } as TweetFilter, args.all ? parent.statusesCount : args.count, args.cursor)
         }
     })
 });
 
-//@ts-ignore
-export const UserList = new GraphQLList(new GraphQLUnionType({
+export const UserList: GraphQLList<GraphQLType> = 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],

package/src/index.ts

@@ -1,7 +1,8 @@
 // SERVICES
 import { AuthService } from "./services/AuthService";
-import { UserAccountService } from "./services/data/UserAccountService";
+import { UserService } from "./services/data/UserService";
 import { TweetService } from "./services/data/TweetService";
+import { AccountService } from "./services/accounts/AccountService";
 
 /**
  * @param cookie The cookies string to use to fetch data
@@ -13,7 +14,8 @@ export const Rettiwt = (cookie: string = '') => {
 
     // Using the auth service instance to create data services instances
     return {
-        users: new UserAccountService(auth),
-        tweets: new TweetService(auth)
+        users: new UserService(auth),
+        tweets: new TweetService(auth),
+        account: new AccountService()
     };
 }

package/src/server.ts

@@ -4,12 +4,13 @@ import { graphqlHTTP } from 'express-graphql';
 import { GraphQLSchema } from 'graphql';
 
 // Services
-import { UserAccountService } from './services/data/UserAccountService';
+import { UserService } from './services/data/UserService';
 import { TweetService } from './services/data/TweetService';
+import { AccountService } from './services/accounts/AccountService';
 import { AuthService } from './services/AuthService';
 
 // SCHEMA
-import { rootQuery } from './queries/RootQuery';
+import { rootQuery } from './graphql/queries/RootQuery';
 
 // CONFIGS
 import { config } from './config/env';
@@ -23,8 +24,9 @@ app.use('/graphql', graphqlHTTP(req => ({
         query: rootQuery
     }),
     context: {
-        users: new UserAccountService(new AuthService(req.headers.cookie as string)),
-        tweets: new TweetService(new AuthService(req.headers.cookie as string))
+        users: new UserService(new AuthService(req.headers.cookie as string)),
+        tweets: new TweetService(new AuthService(req.headers.cookie as string)),
+        account: new AccountService()
     },
     // If app is running in development environment, enable graphiql
     graphiql: config.is_development

package/src/services/AuthService.ts

@@ -2,7 +2,7 @@
 import axios from 'axios';
 
 // URLS
-import { guestTokenUrl } from './helper/Urls';
+import { guestTokenUrl } from './helper/urls/Authentication';
 
 // TYPES
 import { GuestCredentials, AuthCredentials } from '../types/Authentication';

package/src/services/CacheService.ts

@@ -23,16 +23,14 @@ export class CacheService {
     /**
      * @returns The current working instance of CacheService
      */
-    static async getInstance(): Promise<CacheService> {
+    static getInstance(): CacheService {
         // If an instance doesnt exists already
         if (!this.instance) {
             this.instance = new CacheService();
-            return this.instance;
-        }
-        // If an instance already exists, returning it
-        else {
-            return this.instance;
         }
+        
+        // Returning the current instance
+        return this.instance;
     }
 
     /**
@@ -40,7 +38,7 @@ export class CacheService {
      * @returns Whether writing to cache was successful or not
      * @param data The input data to store
      */
-    async write(data: any): Promise<void> {
+    public write(data: any): void {
         // Converting the data to a list of data
         data = Parsers.dataToList(data);
 
@@ -61,7 +59,7 @@ export class CacheService {
      * @returns The data with the given id/rest id from cache
      * @param id The id/rest id of the data to be fetched from cache
      */
-    async read(id: string): Promise<any> {
+    public read(id: string): any {
         // Getting data from cache
         let res = this.client.get(id);