feat: grant Elysian role on auth and prompt non-members to join (#134)

## Summary

- Grants the Elysian Discord role to players on login/registration and persists an `inGuild` flag on the Player record
- Connects to the Discord Gateway via WebSocket to keep `inGuild` in sync as players join or leave the server
- Shows a dismissible "Join our community" modal to players who are not yet in the guild
- Hardens `inGuild` exposure through the load endpoint and game context
- Moves all non-secret Discord IDs (guild, role, client, redirect URI) out of env vars and into hardcoded constants; removes them from `prod.env`

## Test plan

- [ ] Lint, build, and test pipeline passes (100% coverage maintained)
- [ ] New player auth grants Elysian role and sets `inGuild: true`
- [ ] Existing player auth re-attempts role grant and updates `inGuild`
- [ ] Join community modal appears for players not in the guild
- [ ] Modal does not reappear within the same browser session after dismissal
- [ ] Gateway correctly sets `inGuild: true/false` on member add/remove events

✨ This issue was created with help from Hikari~ 🌸

Reviewed-on: #134
Co-authored-by: Hikari <hikari@nhcarrigan.com>
Co-committed-by: Hikari <hikari@nhcarrigan.com>

apps/api/test/services/discord.spec.ts

@@ -18,51 +18,31 @@ describe("discord service", () => {
   });
 
   describe("buildOAuthUrl", () => {
-    it("throws when DISCORD_CLIENT_ID is missing", async () => {
-      delete process.env["DISCORD_CLIENT_ID"];
-      process.env["DISCORD_REDIRECT_URI"] = "http://localhost/callback";
-      const { buildOAuthUrl } = await import("../../src/services/discord.js");
-      expect(() => buildOAuthUrl()).toThrow("Discord OAuth environment variables are required");
-    });
-
-    it("throws when DISCORD_REDIRECT_URI is missing", async () => {
-      process.env["DISCORD_CLIENT_ID"] = "client123";
-      delete process.env["DISCORD_REDIRECT_URI"];
-      const { buildOAuthUrl } = await import("../../src/services/discord.js");
-      expect(() => buildOAuthUrl()).toThrow("Discord OAuth environment variables are required");
-    });
-
     it("returns a URL with correct query params", async () => {
-      process.env["DISCORD_CLIENT_ID"] = "client123";
-      process.env["DISCORD_REDIRECT_URI"] = "http://localhost/callback";
       const { buildOAuthUrl } = await import("../../src/services/discord.js");
       const url = buildOAuthUrl();
-      expect(url).toContain("client_id=client123");
+      expect(url).toContain("client_id=1479551654264049908");
       expect(url).toContain("response_type=code");
       expect(url).toContain("scope=identify");
     });
   });
 
   describe("exchangeCode", () => {
-    it("throws when env vars are missing", async () => {
-      delete process.env["DISCORD_CLIENT_ID"];
+    it("throws when DISCORD_CLIENT_SECRET is missing", async () => {
+      delete process.env["DISCORD_CLIENT_SECRET"];
       const { exchangeCode } = await import("../../src/services/discord.js");
       await expect(exchangeCode("mycode")).rejects.toThrow("Discord OAuth environment variables are required");
     });
 
     it("throws when response is not ok", async () => {
-      process.env["DISCORD_CLIENT_ID"] = "cid";
       process.env["DISCORD_CLIENT_SECRET"] = "secret";
-      process.env["DISCORD_REDIRECT_URI"] = "http://localhost/cb";
       mockFetch.mockResolvedValueOnce({ ok: false, statusText: "Unauthorized" });
       const { exchangeCode } = await import("../../src/services/discord.js");
       await expect(exchangeCode("bad_code")).rejects.toThrow("Discord token exchange failed");
     });
 
     it("returns parsed body on success", async () => {
-      process.env["DISCORD_CLIENT_ID"] = "cid";
       process.env["DISCORD_CLIENT_SECRET"] = "secret";
-      process.env["DISCORD_REDIRECT_URI"] = "http://localhost/cb";
       const tokenData = { access_token: "tok", token_type: "Bearer", expires_in: 3600, refresh_token: "ref", scope: "identify" };
       mockFetch.mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(tokenData) });
       const { exchangeCode } = await import("../../src/services/discord.js");
@@ -96,9 +76,7 @@ describe("discord service", () => {
 
   describe("exchangeCode non-Error throw", () => {
     it("re-throws when fetch rejects with a non-Error value", async () => {
-      process.env["DISCORD_CLIENT_ID"] = "cid";
       process.env["DISCORD_CLIENT_SECRET"] = "secret";
-      process.env["DISCORD_REDIRECT_URI"] = "http://localhost/cb";
       mockFetch.mockRejectedValueOnce("raw string error");
       const { exchangeCode } = await import("../../src/services/discord.js");
       await expect(exchangeCode("some_code")).rejects.toBe("raw string error");

apps/api/test/services/gateway.spec.ts

@@ -0,0 +1,105 @@
+/* eslint-disable max-lines-per-function -- Test suites naturally have many cases */
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("../../src/db/client.js", () => ({
+  prisma: {
+    player: { updateMany: vi.fn() },
+  },
+}));
+
+vi.mock("../../src/services/logger.js", () => ({
+  logger: {
+    error: vi.fn().mockResolvedValue(undefined),
+    log:   vi.fn().mockResolvedValue(undefined),
+  },
+}));
+
+import { prisma } from "../../src/db/client.js";
+
+const discordGuildId = "1354624415861833870";
+
+describe("gateway service", () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe("handleGuildMemberAdd", () => {
+    it("sets inGuild to true for the matching guild", async () => {
+      vi.mocked(prisma.player.updateMany).mockResolvedValueOnce({ count: 1 });
+      const { handleGuildMemberAdd } = await import("../../src/services/gateway.js");
+      await handleGuildMemberAdd("user123", discordGuildId);
+      expect(prisma.player.updateMany).toHaveBeenCalledWith({
+        data:  { inGuild: true },
+        where: { discordId: "user123" },
+      });
+    });
+
+    it("no-ops when guild id does not match the configured guild", async () => {
+      const { handleGuildMemberAdd } = await import("../../src/services/gateway.js");
+      await handleGuildMemberAdd("user123", "other_guild");
+      expect(prisma.player.updateMany).not.toHaveBeenCalled();
+    });
+
+    it("logs error when prisma throws an Error", async () => {
+      const dbError = new Error("DB failure");
+      vi.mocked(prisma.player.updateMany).mockRejectedValueOnce(dbError);
+      const { handleGuildMemberAdd } = await import("../../src/services/gateway.js");
+      const { logger } = await import("../../src/services/logger.js");
+      await handleGuildMemberAdd("user123", discordGuildId);
+      expect(logger.error).toHaveBeenCalledWith("gateway_member_add", dbError);
+    });
+
+    it("logs error when prisma throws a non-Error", async () => {
+      vi.mocked(prisma.player.updateMany).mockRejectedValueOnce("raw error");
+      const { handleGuildMemberAdd } = await import("../../src/services/gateway.js");
+      const { logger } = await import("../../src/services/logger.js");
+      await handleGuildMemberAdd("user123", discordGuildId);
+      expect(logger.error).toHaveBeenCalledWith(
+        "gateway_member_add",
+        new Error("raw error"),
+      );
+    });
+  });
+
+  describe("handleGuildMemberRemove", () => {
+    it("sets inGuild to false for the matching guild", async () => {
+      vi.mocked(prisma.player.updateMany).mockResolvedValueOnce({ count: 1 });
+      const { handleGuildMemberRemove } = await import("../../src/services/gateway.js");
+      await handleGuildMemberRemove("user123", discordGuildId);
+      expect(prisma.player.updateMany).toHaveBeenCalledWith({
+        data:  { inGuild: false },
+        where: { discordId: "user123" },
+      });
+    });
+
+    it("no-ops when guild id does not match the configured guild", async () => {
+      const { handleGuildMemberRemove } = await import("../../src/services/gateway.js");
+      await handleGuildMemberRemove("user123", "other_guild");
+      expect(prisma.player.updateMany).not.toHaveBeenCalled();
+    });
+
+    it("logs error when prisma throws an Error", async () => {
+      const dbError = new Error("DB failure");
+      vi.mocked(prisma.player.updateMany).mockRejectedValueOnce(dbError);
+      const { handleGuildMemberRemove } = await import("../../src/services/gateway.js");
+      const { logger } = await import("../../src/services/logger.js");
+      await handleGuildMemberRemove("user123", discordGuildId);
+      expect(logger.error).toHaveBeenCalledWith("gateway_member_remove", dbError);
+    });
+
+    it("logs error when prisma throws a non-Error", async () => {
+      vi.mocked(prisma.player.updateMany).mockRejectedValueOnce("raw error");
+      const { handleGuildMemberRemove } = await import("../../src/services/gateway.js");
+      const { logger } = await import("../../src/services/logger.js");
+      await handleGuildMemberRemove("user123", discordGuildId);
+      expect(logger.error).toHaveBeenCalledWith(
+        "gateway_member_remove",
+        new Error("raw error"),
+      );
+    });
+  });
+});

apps/api/test/services/webhook.spec.ts

@@ -20,42 +20,20 @@ describe("webhook service", () => {
   describe("grantApotheosisRole", () => {
     it("does nothing when bot token is missing", async () => {
       delete process.env["DISCORD_BOT_TOKEN"];
-      process.env["DISCORD_GUILD_ID"] = "guild123";
-      process.env["DISCORD_APOTHEOSIS_ROLE_ID"] = "role123";
       const { grantApotheosisRole } = await import("../../src/services/webhook.js");
       await grantApotheosisRole("user123");
       expect(mockFetch).not.toHaveBeenCalled();
     });
 
-    it("does nothing when guild id is missing", async () => {
-      process.env["DISCORD_BOT_TOKEN"] = "token";
-      delete process.env["DISCORD_GUILD_ID"];
-      process.env["DISCORD_APOTHEOSIS_ROLE_ID"] = "role123";
-      const { grantApotheosisRole } = await import("../../src/services/webhook.js");
-      await grantApotheosisRole("user123");
-      expect(mockFetch).not.toHaveBeenCalled();
-    });
-
-    it("does nothing when role id is missing", async () => {
-      process.env["DISCORD_BOT_TOKEN"] = "token";
-      process.env["DISCORD_GUILD_ID"] = "guild123";
-      delete process.env["DISCORD_APOTHEOSIS_ROLE_ID"];
-      const { grantApotheosisRole } = await import("../../src/services/webhook.js");
-      await grantApotheosisRole("user123");
-      expect(mockFetch).not.toHaveBeenCalled();
-    });
-
-    it("calls Discord API with correct URL and auth when env vars are set", async () => {
+    it("calls Discord API with correct URL and auth when bot token is set", async () => {
       process.env["DISCORD_BOT_TOKEN"] = "bot_token";
-      process.env["DISCORD_GUILD_ID"] = "guild123";
-      process.env["DISCORD_APOTHEOSIS_ROLE_ID"] = "role456";
       mockFetch.mockResolvedValueOnce({ ok: true });
       const { grantApotheosisRole } = await import("../../src/services/webhook.js");
       await grantApotheosisRole("user789");
       expect(mockFetch).toHaveBeenCalledWith(
-        "https://discord.com/api/v10/guilds/guild123/members/user789/roles/role456",
+        "https://discord.com/api/v10/guilds/1354624415861833870/members/user789/roles/1479966598210129991",
         expect.objectContaining({
-          method: "PUT",
+          method:  "PUT",
           headers: expect.objectContaining({ Authorization: "Bot bot_token" }),
         }),
       );
@@ -63,8 +41,6 @@ describe("webhook service", () => {
 
     it("swallows fetch errors gracefully", async () => {
       process.env["DISCORD_BOT_TOKEN"] = "tok";
-      process.env["DISCORD_GUILD_ID"] = "g";
-      process.env["DISCORD_APOTHEOSIS_ROLE_ID"] = "r";
       mockFetch.mockRejectedValueOnce(new Error("Network error"));
       const { grantApotheosisRole } = await import("../../src/services/webhook.js");
       await expect(grantApotheosisRole("user")).resolves.toBeUndefined();
@@ -72,14 +48,69 @@ describe("webhook service", () => {
 
     it("swallows non-Error fetch rejections gracefully", async () => {
       process.env["DISCORD_BOT_TOKEN"] = "tok";
-      process.env["DISCORD_GUILD_ID"] = "g";
-      process.env["DISCORD_APOTHEOSIS_ROLE_ID"] = "r";
       mockFetch.mockRejectedValueOnce("raw string error");
       const { grantApotheosisRole } = await import("../../src/services/webhook.js");
       await expect(grantApotheosisRole("user")).resolves.toBeUndefined();
     });
   });
 
+  describe("grantElysianRole", () => {
+    it("does nothing when bot token is missing", async () => {
+      delete process.env["DISCORD_BOT_TOKEN"];
+      const { grantElysianRole } = await import("../../src/services/webhook.js");
+      const result = await grantElysianRole("user123");
+      expect(mockFetch).not.toHaveBeenCalled();
+      expect(result).toBe(false);
+    });
+
+    it("returns true when Discord API responds with ok", async () => {
+      process.env["DISCORD_BOT_TOKEN"] = "bot_token";
+      mockFetch.mockResolvedValueOnce({ ok: true, status: 200 });
+      const { grantElysianRole } = await import("../../src/services/webhook.js");
+      const result = await grantElysianRole("user789");
+      expect(mockFetch).toHaveBeenCalledWith(
+        "https://discord.com/api/v10/guilds/1354624415861833870/members/user789/roles/1486144823684628490",
+        expect.objectContaining({
+          method:  "PUT",
+          headers: expect.objectContaining({ Authorization: "Bot bot_token" }),
+        }),
+      );
+      expect(result).toBe(true);
+    });
+
+    it("returns true when Discord API responds with 204", async () => {
+      process.env["DISCORD_BOT_TOKEN"] = "tok";
+      mockFetch.mockResolvedValueOnce({ ok: false, status: 204 });
+      const { grantElysianRole } = await import("../../src/services/webhook.js");
+      const result = await grantElysianRole("user");
+      expect(result).toBe(true);
+    });
+
+    it("returns false when Discord API responds with an error status", async () => {
+      process.env["DISCORD_BOT_TOKEN"] = "tok";
+      mockFetch.mockResolvedValueOnce({ ok: false, status: 403 });
+      const { grantElysianRole } = await import("../../src/services/webhook.js");
+      const result = await grantElysianRole("user");
+      expect(result).toBe(false);
+    });
+
+    it("returns false and swallows fetch errors gracefully", async () => {
+      process.env["DISCORD_BOT_TOKEN"] = "tok";
+      mockFetch.mockRejectedValueOnce(new Error("Network error"));
+      const { grantElysianRole } = await import("../../src/services/webhook.js");
+      const result = await grantElysianRole("user");
+      expect(result).toBe(false);
+    });
+
+    it("returns false and swallows non-Error fetch rejections", async () => {
+      process.env["DISCORD_BOT_TOKEN"] = "tok";
+      mockFetch.mockRejectedValueOnce("raw string error");
+      const { grantElysianRole } = await import("../../src/services/webhook.js");
+      const result = await grantElysianRole("user");
+      expect(result).toBe(false);
+    });
+  });
+
   describe("postMilestoneWebhook", () => {
     const counts = { prestige: 1, transcendence: 0, apotheosis: 0 };