lerna: complete refactor!

packages/roleypoly-server/services/discord/restFetcher.js

@@ -2,33 +2,71 @@
 import type { IFetcher } from './types'
 import type DiscordSvc from '../discord'
 import type ErisClient, { User, Member, Guild } from 'eris'
+import LRU from 'lru-cache'
+import logger from '../../logger'
+const log = logger(__filename)
 
 export default class BotFetcher implements IFetcher {
   ctx: DiscordSvc
   client: ErisClient
+  cache: LRU<string, Guild | Member | User>
+
   constructor (ctx: DiscordSvc) {
     this.ctx = ctx
     this.client = ctx.client
+    this.cache = new LRU({
+      max: 50,
+      maxAge: 1000 * 60 * 10
+    })
   }
 
   getUser = async (id: string): Promise<?User> => {
+    if (this.cache.has(`U:${id}`)) {
+      log.debug('user cache hit')
+      return this.cache.get(`U:${id}`)
+    }
+
+    log.debug('user cache miss')
+
     try {
-      return await this.client.getRESTUser(id)
+      const u = await this.client.getRESTUser(id)
+      this.cache.set(`U:${id}`, u)
+      return u
     } catch (e) {
       return null
     }
   }
   getMember = async (server: string, user: string): Promise<?Member> => {
+    if (this.cache.has(`M:${server}:${user}`)) {
+      log.debug('member cache hit')
+      return this.cache.get(`M:${server}:${user}`)
+    }
+
+    log.debug('member cache miss')
+
     try {
-      return await this.client.getRESTGuildMember(server, user)
+      const m = await this.client.getRESTGuildMember(server, user)
+      this.cache.set(`M:${server}:${user}`, m)
+      // $FlowFixMe
+      m.guild = await this.getGuild(server) // we have to prefill this for whatever reason
+      return m
     } catch (e) {
       return null
     }
   }
 
   getGuild = async (server: string): Promise<?Guild> => {
+    if (this.cache.has(`G:${server}`)) {
+      log.debug('guild cache hit')
+      return this.cache.get(`G:${server}`)
+    }
+
+    log.debug('guild cache miss')
+
     try {
-      return await this.client.getRESTGuild(server)
+      const g = await this.client.getRESTGuild(server)
+      this.cache.set(`G:${server}`, g)
+      return g
     } catch (e) {
       return null
     }

packages/roleypoly-server/services/presentation.js

@@ -4,41 +4,18 @@ import LRU from 'lru-cache'
 import { type AppContext } from '../Roleypoly'
 import { type Models } from '../models'
 import { type ServerModel } from '../models/Server'
-import type DiscordService, { Permissions } from './discord'
+import type DiscordService from './discord'
 import {
   type Guild,
-  type Member,
   type Collection
 } from 'eris'
+import type {
+  Member,
+  PresentableServer,
+  ServerSlug,
+  PresentableRole
+} from '@roleypoly/types'
 import areduce from '../util/areduce'
-
-export type ServerSlug = {
-  id: string,
-  name: string,
-  ownerID: string,
-  icon: string
-}
-
-export type PresentableRole = {
-  id: string,
-  color: number,
-  name: string,
-  position: number,
-  safe: boolean
-}
-
-export type PresentableServer = ServerModel & {
-  id: string,
-  gm?: {
-    color: number | string,
-    nickname: string,
-    roles: string[]
-  },
-  server: ServerSlug,
-  roles: ?PresentableRole[],
-  perms: Permissions
-}
-
 class PresentationService extends Service {
   cache: LRU
   M: Models
@@ -61,8 +38,8 @@ class PresentationService extends Service {
     }
   }
 
-  presentableServers (collection: Collection<string, Guild>, userId: string) {
-    return areduce(collection.array(), async (acc, server) => {
+  presentableServers (collection: Collection<Guild>, userId: string) {
+    return areduce(Array.from(collection.values()), async (acc, server) => {
       const gm = server.members.get(userId)
       if (gm == null) {
         throw new Error(`somehow this guildmember ${userId} of ${server.id} didn't exist.`)
@@ -79,12 +56,12 @@ class PresentationService extends Service {
     return {
       id: server.id,
       gm: {
-        nickname: gm.nickname || gm.user.username,
-        color: gm.displayHexColor,
-        roles: gm.roles.keyArray()
+        nickname: gm.nick || gm.user.username,
+        color: gm?.color,
+        roles: gm.roles
       },
       server: this.serverSlug(server),
-      roles: (incRoles) ? (await this.rolesByServer(server, sd)).map(r => ({ ...r, selected: gm.roles.has(r.id) })) : [],
+      roles: (incRoles) ? (await this.rolesByServer(server, sd)).map(r => ({ ...r, selected: gm.roles.includes(r.id) })) : [],
       message: sd.message,
       categories: sd.categories,
       perms: this.discord.getPermissions(gm)