feat - redis expiry for guilds

Author: jaga-live

src/api/discord/guild.ts

@@ -5,7 +5,7 @@ import { configStore } from '../../shared/store/config.store';
 
 @injectable()
 export class GuildAPI extends DiscordBaseAPI {
-  ///Get Guild using guild Id
+  /**Get Guild using guild Id */
   getGuild(guildId: string) {
     return {
       method: 'GET',
@@ -17,4 +17,20 @@ export class GuildAPI extends DiscordBaseAPI {
       endpointType: `getGuild:{${guildId}}`,
     } as IDiscordAxiosConfig;
   }
+
+  /**Get all guilds */
+  getAllGuild(limit: number) {
+    return {
+      method: 'GET',
+      url: `${this.DISCORD_API}/users/@me/guilds`,
+      headers: {
+        Authorization: this.authorization(configStore.clientOptions.token),
+        ...this.headers,
+      },
+      params: {
+        limit,
+      },
+      endpointType: `getAllGuild`,
+    } as IDiscordAxiosConfig;
+  }
 }

src/api/discord/user.ts

@@ -1,6 +1,7 @@
 import { injectable } from 'inversify';
 import { DiscordBaseAPI } from './api.discord';
 import { IDiscordAxiosConfig } from '../../modules/shared/axios.service';
+import { configStore } from '../../shared/store/config.store';
 
 @injectable()
 export class UserAPI extends DiscordBaseAPI {
@@ -16,6 +17,19 @@ export class UserAPI extends DiscordBaseAPI {
     } as IDiscordAxiosConfig;
   }
 
+  /**Send Message to a user */
+  createChannel(recipient_id: string) {
+    return {
+      method: 'POST',
+      url: `${this.DISCORD_API}/users/@me/channels`,
+      headers: {
+        Authorization: this.authorization(configStore.clientOptions.token),
+        ...this.headers,
+      },
+      data: { recipient_id },
+    } as IDiscordAxiosConfig;
+  }
+
   /**Get User Guid;s */
   guilds(accessToken: string) {
     return {

src/modules/client/client.ts

@@ -54,7 +54,7 @@ export class Client extends EventEmitter {
     this.message = new Message(messageService);
     this.roles = new Roles(rolesService);
     this.bot = new Bot();
-    this.user = new User(userService);
+    this.user = new User(userService, messageService, redisService);
 
     /**App config */
     new RedisProvider().validate(this.options);

src/modules/guild/guild.ts

@@ -40,12 +40,21 @@ export class Guild {
     const guild = await this.guildService.getGuildById(guildId);
 
     if (this.options.sync) {
-      await this.redisService.set(`cache:${guildId}`, JSON.stringify(guild));
+      await this.redisService.setWithExpiry(
+        `cache:${guildId}`,
+        JSON.stringify(guild),
+        600,
+      );
     } else {
       this.cachedGuildIds.add(guildId);
       this.cachedGuildData.set(guildId, guild);
     }
 
     return guild;
   }
+
+  /**Fetch all Guilds */
+  async fetchAll(limit?: number) {
+    return this.guildService.getAllGuild(limit || 100);
+  }
 }

src/modules/guild/service/guild.service.ts

@@ -14,4 +14,9 @@ export class GuildService {
     const apiConfig = this.guildAPI.getGuild(guildId);
     return this.axiosService.discordRequest(apiConfig);
   }
+
+  async getAllGuild(limit: number) {
+    const apiConfig = this.guildAPI.getAllGuild(limit);
+    return this.axiosService.discordRequest(apiConfig);
+  }
 }

src/modules/member/member.ts

@@ -43,7 +43,11 @@ export class Member {
     const guild = await this.memberService.getMemberById(guildId, memberId);
 
     if (clientOptions.sync) {
-      await this.redisService.set(`cache:${guildId}`, JSON.stringify(guild));
+      await this.redisService.setWithExpiry(
+        `cache:${guildId}`,
+        JSON.stringify(guild),
+        600,
+      );
     } else {
       this.cachedMemberIds.add(guildId);
       this.cachedMemberData.set(guildId, guild);

src/modules/shared/axios.service.ts

@@ -6,6 +6,7 @@ import { DiscordRateLimiter } from './rate_limiter';
 export interface IAxiosConfig {
   method: string;
   url: string;
+  params?: any;
   data?: any;
 }
 

src/modules/users/service/user.service.ts

@@ -15,6 +15,11 @@ export class UserService {
     return this.axiosService.discordRequest(apiConfig);
   }
 
+  async createChannel(recipient_id: string) {
+    const apiConfig = this.userAPI.createChannel(recipient_id);
+    return this.axiosService.discordRequest(apiConfig);
+  }
+
   async guilds(accessToken: string) {
     const apiConfig = this.userAPI.guilds(accessToken);
     return this.axiosService.discordRequest(apiConfig);

src/modules/users/user.ts

@@ -2,16 +2,39 @@ import 'reflect-metadata';
 import { inject } from 'inversify';
 import { TYPES } from '../../core/types.di';
 import { UserService } from './service/user.service';
+import { RedisService } from '../shared/redis/redis.service';
+import { MessageService } from '../message/service/message.service';
 
 export class User {
   constructor(
     @inject(TYPES.UserService) private readonly userService: UserService,
+    @inject(TYPES.MessageService)
+    private readonly messageService: MessageService,
+    @inject(TYPES.RedisService) private readonly redisService: RedisService,
   ) {}
 
   async profile(accessToken: string) {
     return this.userService.profile(accessToken);
   }
 
+  /**This method uses only Redis as of now
+   * TODO - Add support for app cache!
+   */
+  async sendMessage(userId: string, message: string) {
+    let channelId: string;
+
+    const getUserChannel = await this.redisService.get(`userChannel:${userId}`);
+    channelId = getUserChannel;
+
+    if (!getUserChannel) {
+      const channel = await this.userService.createChannel(userId);
+      channelId = channel.id;
+
+      await this.redisService.set(`userChannel:${userId}`, channel.id);
+    }
+    return this.messageService.sendMessage(channelId, message);
+  }
+
   async guilds(accessToken: string) {
     return this.userService.guilds(accessToken);
   }