Add some Discord API calls for managing guilds (#147)

This is essentially WIP, but it's in a merge-able state so I'm opening
it for PR. It has some useful (but incomplete) functions and concepts
around identity and permissions, but there's still work to be done on
it.

Author: vcarl

app/components/login.tsx

@@ -1,13 +1,3 @@
-import { Logout } from "#~/basics/logout";
-
 export function ServerOverview() {
-  return (
-    <main className="">
-      <nav>
-        <Logout />
-      </nav>
-      <section></section>
-      <footer></footer>
-    </main>
-  );
+  return <div>butts (ServerOverview)</div>;
 }

app/components/logout.tsx

@@ -14,3 +14,8 @@ export const partition = <Data>(predicate: (d: Data) => boolean, xs: Data[]) =>
     },
     [[], []] as [Data[], Data[]],
   );
+
+/**
+ * ElementType is a helper type to turn `Array<T>` into `T`
+ */
+export type ElementType<T> = T extends (infer U)[] ? U : T;

app/features/ServerOverview/ServerOverview.tsx

@@ -1,2 +1,38 @@
 export const difference = <T>(a: Set<T>, b: Set<T>) =>
   new Set(Array.from(a).filter((x) => !b.has(x)));
+
+/**
+ * Returns the intersection of two sets - elements that exist in both sets
+ * @param setA First set
+ * @param setB Second set
+ * @returns A new Set containing elements present in both input sets
+ */
+export function intersection<T>(setA: Set<T>, setB: Set<T>): Set<T> {
+  const result = new Set<T>();
+
+  for (const elem of setA) {
+    if (setB.has(elem)) {
+      result.add(elem);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Returns the complement (difference) of two sets - elements in setA that are not in setB
+ * @param setA First set
+ * @param setB Second set
+ * @returns A new Set containing elements present in setA but not in setB
+ */
+export function complement<T>(setA: Set<T>, setB: Set<T>): Set<T> {
+  const result = new Set<T>();
+
+  for (const elem of setA) {
+    if (!setB.has(elem)) {
+      result.add(elem);
+    }
+  }
+
+  return result;
+}

app/helpers/array.ts

@@ -1,4 +1,14 @@
-import type { GuildMember } from "discord.js";
+import {
+  Routes,
+  type APIGuild,
+  PermissionFlagsBits,
+} from "discord-api-types/v10";
+
+import type { REST } from "@discordjs/rest";
+import { type GuildMember } from "discord.js";
+
+import { complement, intersection } from "#~/helpers/sets.js";
+
 import type { AccessToken } from "simple-oauth2";
 import { fetchSettings, SETTINGS } from "#~/models/guilds.server";
 
@@ -88,3 +98,101 @@ export const timeout = async (member: GuildMember | null) => {
   }
   return member.timeout(OVERNIGHT);
 };
+
+const authzRoles = {
+  mod: "MOD",
+  admin: "ADMIN",
+  manager: "MANAGER",
+  manageChannels: "MANAGE_CHANNELS",
+  manageGuild: "MANAGE_GUILD",
+  manageRoles: "MANAGE_ROLES",
+} as const;
+
+const isUndefined = (x: unknown): x is undefined => typeof x === "undefined";
+
+const processGuild = (g: APIGuild) => {
+  const perms = BigInt(g.permissions || 0);
+  const authz = new Set<(typeof authzRoles)[keyof typeof authzRoles]>();
+
+  if (perms & PermissionFlagsBits.Administrator) {
+    authz.add(authzRoles.admin);
+  }
+  if (perms & PermissionFlagsBits.ModerateMembers) {
+    authz.add(authzRoles.mod);
+  }
+  if (perms & PermissionFlagsBits.ManageChannels) {
+    authz.add(authzRoles.manageChannels);
+    authz.add(authzRoles.manager);
+  }
+  if (perms & PermissionFlagsBits.ManageGuild) {
+    authz.add(authzRoles.manageGuild);
+    authz.add(authzRoles.manager);
+  }
+  if (perms & PermissionFlagsBits.ManageRoles) {
+    authz.add(authzRoles.manageRoles);
+    authz.add(authzRoles.manager);
+  }
+
+  return {
+    id: g.id as string,
+    icon: g.icon,
+    name: g.name as string,
+    authz: [...authz.values()],
+  };
+};
+
+export interface Guild extends ReturnType<typeof processGuild> {
+  hasBot: boolean;
+}
+
+export const fetchGuilds = async (
+  userRest: REST,
+  botRest: REST,
+): Promise<Guild[]> => {
+  const [rawUserGuilds, rawBotGuilds] = (await Promise.all([
+    userRest.get(Routes.userGuilds()),
+    botRest.get(Routes.userGuilds()),
+  ])) as [APIGuild[], APIGuild[]];
+
+  const botGuilds = new Map(
+    rawBotGuilds.reduce(
+      (accum, val) => {
+        const guild = processGuild(val);
+        if (guild.authz.length > 0) {
+          accum.push([val.id, guild]);
+        }
+        return accum;
+      },
+      [] as [string, Omit<Guild, "hasBot">][],
+    ),
+  );
+  const userGuilds = new Map(
+    rawUserGuilds.reduce(
+      (accum, val) => {
+        const guild = processGuild(val);
+        if (guild.authz.includes("MANAGER")) {
+          accum.push([val.id, guild]);
+        }
+        return accum;
+      },
+      [] as [string, Omit<Guild, "hasBot">][],
+    ),
+  );
+
+  const botGuildIds = new Set(botGuilds.keys());
+  const userGuildIds = new Set(userGuilds.keys());
+
+  const manageableGuilds = intersection(botGuildIds, userGuildIds);
+  const invitableGuilds = complement(userGuildIds, botGuildIds);
+
+  return [
+    ...[...manageableGuilds].map((gId) => {
+      const guild = botGuilds.get(gId);
+      return guild ? { ...guild, hasBot: true } : undefined;
+    }),
+    ...[...invitableGuilds].map((gId) => {
+      const guild = botGuilds.get(gId);
+      return guild ? { ...guild, hasBot: false } : undefined;
+    }),
+  ].filter((g) => !isUndefined(g));
+};

app/helpers/sets.ts

@@ -107,18 +107,18 @@ const {
 export type DbSession = Awaited<ReturnType<typeof getDbSession>>;
 
 export const CookieSessionKeys = {
-  userId: "userId",
   discordToken: "discordToken",
+  authState: "state",
+  authRedirect: "redirectTo",
 } as const;
 
 export const DbSessionKeys = {
-  authState: "state",
-  authRedirect: "redirectTo",
+  userId: "userId",
 } as const;
 
 async function getUserId(request: Request): Promise<string | undefined> {
-  const session = await getCookieSession(request.headers.get("Cookie"));
-  const userId = session.get(CookieSessionKeys.userId);
+  const session = await getDbSession(request.headers.get("Cookie"));
+  const userId = session.get(DbSessionKeys.userId);
   return userId;
 }
 
@@ -162,14 +162,14 @@ export async function initOauthLogin({
   redirectTo?: string;
 }) {
   const { origin } = new URL(request.url);
-  const dbSession = await getDbSession(request.headers.get("Cookie"));
+  const cookieSession = await getCookieSession(request.headers.get("Cookie"));
 
   const state = randomUUID();
-  dbSession.set(DbSessionKeys.authState, state);
+  cookieSession.set(CookieSessionKeys.authState, state);
   if (redirectTo) {
-    dbSession.set(DbSessionKeys.authRedirect, redirectTo);
+    cookieSession.set(CookieSessionKeys.authRedirect, redirectTo);
   }
-  const cookie = await commitDbSession(dbSession, {
+  const cookie = await commitCookieSession(cookieSession, {
     maxAge: 60 * 60 * 1, // 1 hour
   });
   return redirect(
@@ -221,17 +221,16 @@ export async function completeOauthLogin(
     getDbSession(reqCookie),
   ]);
 
-  const dbState = dbSession.get(DbSessionKeys.authState);
+  const dbState = cookieSession.get(CookieSessionKeys.authState);
   // Redirect to login if the state arg doesn't match
   if (dbState !== state) {
     console.error("DB state didn’t match cookie state");
     throw redirect("/login");
   }
 
-  cookieSession.set(CookieSessionKeys.userId, userId);
+  dbSession.set(DbSessionKeys.userId, userId);
   // @ts-expect-error token.toJSON() isn't in the types but it works
   cookieSession.set(CookieSessionKeys.discordToken, token.toJSON());
-  dbSession.unset(DbSessionKeys.authState);
   const [cookie, dbCookie] = await Promise.all([
     commitCookieSession(cookieSession, {
       maxAge: 60 * 60 * 24 * 7, // 7 days
@@ -242,7 +241,7 @@ export async function completeOauthLogin(
   headers.append("Set-Cookie", cookie);
   headers.append("Set-Cookie", dbCookie);
 
-  return redirect(dbSession.get(DbSessionKeys.authRedirect) ?? "/", {
+  return redirect(cookieSession.get(CookieSessionKeys.authRedirect) ?? "/", {
     headers,
   });
 }

app/models/discord.server.ts

@@ -1,6 +1,6 @@
 import type { Route } from "./+types/__auth";
 import { Outlet, useLocation, type LoaderFunctionArgs } from "react-router";
-import { Login } from "#~/components/login";
+import { Login } from "#~/basics/login";
 import { isProd } from "#~/helpers/env.server";
 import { getUser } from "#~/models/session.server";
 import { useOptionalUser } from "#~/utils";

app/models/session.server.ts

@@ -2,7 +2,7 @@ import type { Route } from "./+types/auth";
 import { redirect } from "react-router";
 
 import { initOauthLogin } from "#~/models/session.server";
-import { Login } from "#~/components/login";
+import { Login } from "#~/basics/login";
 
 // eslint-disable-next-line no-empty-pattern
 export async function loader({}: Route.LoaderArgs) {