feat: add member cache; handle all role changes with RoleManagerPlugin; exit gracefully

backend/src/plugins/GuildMemberCache/GuildMemberCachePlugin.ts

@@ -0,0 +1,53 @@
+import * as t from "io-ts";
+import { GuildMemberCache } from "../../data/GuildMemberCache";
+import { makeIoTsConfigParser, mapToPublicFn } from "../../pluginUtils";
+import { SECONDS } from "../../utils";
+import { zeppelinGuildPlugin } from "../ZeppelinPluginBlueprint";
+import { cancelDeletionOnMemberJoin } from "./events/cancelDeletionOnMemberJoin";
+import { removeMemberCacheOnMemberLeave } from "./events/removeMemberCacheOnMemberLeave";
+import { updateMemberCacheOnMemberUpdate } from "./events/updateMemberCacheOnMemberUpdate";
+import { updateMemberCacheOnMessage } from "./events/updateMemberCacheOnMessage";
+import { updateMemberCacheOnRoleChange } from "./events/updateMemberCacheOnRoleChange";
+import { updateMemberCacheOnVoiceStateUpdate } from "./events/updateMemberCacheOnVoiceStateUpdate";
+import { getCachedMemberData } from "./functions/getCachedMemberData";
+import { GuildMemberCachePluginType } from "./types";
+
+const PENDING_SAVE_INTERVAL = 30 * SECONDS;
+
+export const GuildMemberCachePlugin = zeppelinGuildPlugin<GuildMemberCachePluginType>()({
+  name: "guild_member_cache",
+  showInDocs: false,
+
+  configParser: makeIoTsConfigParser(t.type({})),
+
+  events: [
+    updateMemberCacheOnMemberUpdate,
+    updateMemberCacheOnMessage,
+    updateMemberCacheOnVoiceStateUpdate,
+    updateMemberCacheOnRoleChange,
+    removeMemberCacheOnMemberLeave,
+    cancelDeletionOnMemberJoin,
+  ],
+
+  public: {
+    getCachedMemberData: mapToPublicFn(getCachedMemberData),
+  },
+
+  beforeLoad(pluginData) {
+    pluginData.state.memberCache = GuildMemberCache.getGuildInstance(pluginData.guild.id);
+    // This won't leak memory... too much #trust
+    pluginData.state.initialUpdatedMembers = new Set();
+  },
+
+  afterLoad(pluginData) {
+    pluginData.state.saveInterval = setInterval(
+      () => pluginData.state.memberCache.savePendingUpdates(),
+      PENDING_SAVE_INTERVAL,
+    );
+  },
+
+  async beforeUnload(pluginData) {
+    clearInterval(pluginData.state.saveInterval);
+    await pluginData.state.memberCache.savePendingUpdates();
+  },
+});

backend/src/plugins/GuildMemberCache/events/cancelDeletionOnMemberJoin.ts

@@ -0,0 +1,9 @@
+import { guildPluginEventListener } from "knub";
+import { GuildMemberCachePluginType } from "../types";
+
+export const cancelDeletionOnMemberJoin = guildPluginEventListener<GuildMemberCachePluginType>()({
+  event: "guildMemberAdd",
+  async listener({ pluginData, args: { member } }) {
+    pluginData.state.memberCache.unmarkMemberForDeletion(member.id);
+  },
+});

backend/src/plugins/GuildMemberCache/events/removeMemberCacheOnMemberLeave.ts

@@ -0,0 +1,12 @@
+import { guildPluginEventListener } from "knub";
+import { MINUTES } from "../../../utils";
+import { GuildMemberCachePluginType } from "../types";
+
+const DELETION_DELAY = 2 * MINUTES;
+
+export const removeMemberCacheOnMemberLeave = guildPluginEventListener<GuildMemberCachePluginType>()({
+  event: "guildMemberRemove",
+  async listener({ pluginData, args: { member } }) {
+    pluginData.state.memberCache.markMemberForDeletion(member.id);
+  },
+});

backend/src/plugins/GuildMemberCache/events/updateMemberCacheOnMemberUpdate.ts

@@ -0,0 +1,15 @@
+import { AuditLogEvent } from "discord.js";
+import { guildPluginEventListener } from "knub";
+import { updateMemberCacheForMember } from "../functions/updateMemberCacheForMember";
+import { GuildMemberCachePluginType } from "../types";
+
+export const updateMemberCacheOnMemberUpdate = guildPluginEventListener<GuildMemberCachePluginType>()({
+  event: "guildAuditLogEntryCreate",
+  async listener({ pluginData, args: { auditLogEntry } }) {
+    if (auditLogEntry.action !== AuditLogEvent.MemberUpdate) {
+      return;
+    }
+
+    updateMemberCacheForMember(pluginData, auditLogEntry.targetId!);
+  },
+});

backend/src/plugins/GuildMemberCache/events/updateMemberCacheOnMessage.ts

@@ -0,0 +1,16 @@
+import { guildPluginEventListener } from "knub";
+import { updateMemberCacheForMember } from "../functions/updateMemberCacheForMember";
+import { GuildMemberCachePluginType } from "../types";
+
+export const updateMemberCacheOnMessage = guildPluginEventListener<GuildMemberCachePluginType>()({
+  event: "messageCreate",
+  listener({ pluginData, args }) {
+    // Update each member once per guild load when we see a message from them
+    const key = `${pluginData.guild.id}-${args.message.author.id}`;
+    if (pluginData.state.initialUpdatedMembers.has(key)) {
+      return;
+    }
+    updateMemberCacheForMember(pluginData, args.message.author.id);
+    pluginData.state.initialUpdatedMembers.add(key);
+  },
+});

backend/src/plugins/GuildMemberCache/events/updateMemberCacheOnRoleChange.ts

@@ -0,0 +1,15 @@
+import { AuditLogEvent } from "discord.js";
+import { guildPluginEventListener } from "knub";
+import { updateMemberCacheForMember } from "../functions/updateMemberCacheForMember";
+import { GuildMemberCachePluginType } from "../types";
+
+export const updateMemberCacheOnRoleChange = guildPluginEventListener<GuildMemberCachePluginType>()({
+  event: "guildAuditLogEntryCreate",
+  async listener({ pluginData, args: { auditLogEntry } }) {
+    if (auditLogEntry.action !== AuditLogEvent.MemberRoleUpdate) {
+      return;
+    }
+
+    updateMemberCacheForMember(pluginData, auditLogEntry.targetId!);
+  },
+});

backend/src/plugins/GuildMemberCache/events/updateMemberCacheOnVoiceStateUpdate.ts

@@ -0,0 +1,20 @@
+import { guildPluginEventListener } from "knub";
+import { updateMemberCacheForMember } from "../functions/updateMemberCacheForMember";
+import { GuildMemberCachePluginType } from "../types";
+
+export const updateMemberCacheOnVoiceStateUpdate = guildPluginEventListener<GuildMemberCachePluginType>()({
+  event: "voiceStateUpdate",
+  listener({ pluginData, args }) {
+    const memberId = args.newState.member?.id;
+    if (!memberId) {
+      return;
+    }
+    // Update each member once per guild load when we see a message from them
+    const key = `${pluginData.guild.id}-${memberId}`;
+    if (pluginData.state.initialUpdatedMembers.has(key)) {
+      return;
+    }
+    updateMemberCacheForMember(pluginData, memberId);
+    pluginData.state.initialUpdatedMembers.add(key);
+  },
+});

backend/src/plugins/GuildMemberCache/functions/getCachedMemberData.ts

@@ -0,0 +1,10 @@
+import { GuildPluginData } from "knub";
+import { MemberCacheItem } from "../../../data/entities/MemberCacheItem";
+import { GuildMemberCachePluginType } from "../types";
+
+export function getCachedMemberData(
+  pluginData: GuildPluginData<GuildMemberCachePluginType>,
+  userId: string,
+): Promise<MemberCacheItem | null> {
+  return pluginData.state.memberCache.getCachedMemberData(userId);
+}

backend/src/plugins/GuildMemberCache/functions/updateMemberCacheForMember.ts

@@ -0,0 +1,17 @@
+import { GuildPluginData } from "knub";
+import { GuildMemberCachePluginType } from "../types";
+
+export async function updateMemberCacheForMember(
+  pluginData: GuildPluginData<GuildMemberCachePluginType>,
+  userId: string,
+) {
+  const upToDateMember = await pluginData.guild.members.fetch(userId);
+  const roles = Array.from(upToDateMember.roles.cache.keys())
+    // Filter out @everyone role
+    .filter((roleId) => roleId !== pluginData.guild.id);
+  pluginData.state.memberCache.setCachedMemberData(upToDateMember.id, {
+    username: upToDateMember.user.username,
+    nickname: upToDateMember.nickname,
+    roles,
+  });
+}

backend/src/plugins/GuildMemberCache/types.ts

@@ -0,0 +1,10 @@
+import { BasePluginType } from "knub";
+import { GuildMemberCache } from "../../data/GuildMemberCache";
+
+export interface GuildMemberCachePluginType extends BasePluginType {
+  state: {
+    memberCache: GuildMemberCache;
+    saveInterval: NodeJS.Timeout;
+    initialUpdatedMembers: Set<string>;
+  };
+}