feat(bot): add guild events

src/db/discord.ts

@@ -6,6 +6,7 @@ import { db } from "./db";
 import {
     dbGuildYouTubeSubscriptionsTable,
     dbGuildTwitchSubscriptionsTable,
+    dbDiscordTable,
 } from "./schema";
 
 export async function checkIfGuildIsTrackingUserAlready(
@@ -280,3 +281,46 @@ export async function discordRemoveGuildTrackingChannel(
         return { success: false, data: [] };
     }
 }
+
+// Add a new guild to track
+export async function discordAddNewGuild(
+    guildId: string,
+): Promise<{ success: boolean; data: [] }> {
+    console.log(`Adding new guild to track: ${guildId}`);
+
+    try {
+        await db.insert(dbDiscordTable).values({
+            guildId: guildId,
+            allowedPublicSharing: false,
+            isInServer: true,
+            memberCount: 0,
+        });
+
+        return { success: true, data: [] };
+    } catch (error) {
+        console.error("Error adding new guild to track:", error);
+
+        return { success: false, data: [] };
+    }
+}
+
+// "Remove" a guild from tracking
+// Basically just set isInServer to false for archival purposes
+export async function discordRemoveGuildFromTracking(
+    guildId: string,
+): Promise<{ success: boolean; data: [] }> {
+    console.log(`Removing guild from tracking: ${guildId}`);
+
+    try {
+        await db
+            .update(dbDiscordTable)
+            .set({ isInServer: false })
+            .where(eq(dbDiscordTable.guildId, guildId));
+
+        return { success: true, data: [] };
+    } catch (error) {
+        console.error("Error removing guild from tracking:", error);
+
+        return { success: false, data: [] };
+    }
+}

src/db/schema.ts

@@ -8,6 +8,7 @@ export const dbDiscordTable = pgTable("discord", {
     allowedPublicSharing: boolean("allowed_public_sharing").notNull().default(false),
     feedrUpdatesChannelId: text("feedr_updates_channel_id"),
     isInServer: boolean("is_in_server").notNull().default(true),
+    memberCount: integer("member_count").notNull().default(0),
 });
 
 export const dbBlueskyTable = pgTable("bluesky", {

src/events/guildCreate.ts

@@ -0,0 +1,17 @@
+import { Events } from "discord.js";
+
+import client from "..";
+import { discordAddNewGuild } from "../db/discord";
+
+client.on(Events.GuildCreate, async (guild) => {
+    console.log(`Joined new guild: ${guild.name} (ID: ${guild.id})`);
+
+    // Add the new guild to tracking
+    const result = await discordAddNewGuild(guild.id);
+
+    if (result.success) {
+        console.log(`Successfully added guild ${guild.id} to tracking.`);
+    } else {
+        console.error(`Failed to add guild ${guild.id} to tracking.`);
+    }
+});

src/events/guildDelete.ts

@@ -0,0 +1,17 @@
+import { Events } from "discord.js";
+
+import client from "..";
+import { discordRemoveGuildFromTracking } from "../db/discord";
+
+client.on(Events.GuildDelete, async (guild) => {
+    console.log(`Left guild: ${guild.name} (ID: ${guild.id})`);
+
+    // Remove the guild from tracking
+    const result = await discordRemoveGuildFromTracking(guild.id);
+
+    if (result.success) {
+        console.log(`Successfully removed guild ${guild.id} from tracking.`);
+    } else {
+        console.error(`Failed to remove guild ${guild.id} from tracking.`);
+    }
+});

src/index.ts

@@ -14,6 +14,7 @@ import {
 import { env } from "./config.ts";
 import commandsMap from "./commands.ts";
 import { getTwitchToken } from "./utils/twitch/auth.ts";
+import updateGuildsOnStartup from "./utils/discord/updateGuildsOnStartup.ts";
 
 if (!env.discordToken || env.discordToken === "YOUR_DISCORD_TOKEN") {
     throw new Error("You MUST provide a discord token in .env!");
@@ -75,6 +76,9 @@ await Promise.all(
     }),
 );
 
+// Update the guilds on startup
+await updateGuildsOnStartup();
+
 // Attempt the garbage collection every hour
 setInterval(
     () => {

src/utils/discord/updateGuildsOnStartup.ts

@@ -0,0 +1,78 @@
+// Checks for any guilds that may have been added/removed while the bot was offline
+import { eq } from "drizzle-orm";
+
+import { dbDiscordTable } from "../../db/schema";
+import client from "../..";
+import { db } from "../../db/db";
+
+export default async function () {
+    console.log("Checking for guilds to update on startup...");
+
+    let currentGuilds: string[] = [];
+
+    // Keep checking every 10 seconds until currentGuilds is not empty
+    while (currentGuilds.length === 0) {
+        console.log("Waiting for guilds to load...");
+        currentGuilds = client.guilds.cache.map((guild) => guild.id);
+        if (currentGuilds.length === 0) {
+            await new Promise((resolve) => setTimeout(resolve, 10000));
+        }
+    }
+
+    // Get all the guilds from the database
+    const data = await db.select().from(dbDiscordTable);
+
+    console.log(
+        `Currently in ${currentGuilds.length} guilds, checking against ${data.length} in the database.`,
+    );
+
+    // Find any guilds that are in the database but not in the current guilds
+    const missingGuilds = data.filter(
+        (guild) => !currentGuilds.includes(guild.guildId),
+    );
+
+    // Find any guilds that are in the current guilds but not in the database
+    const newGuilds = currentGuilds.filter(
+        (id) => !data.some((guild) => guild.guildId === id),
+    );
+
+    // Update the database for missing guilds
+    missingGuilds.forEach(async (guild) => {
+        console.log(`Removing guild from tracking: ${guild.guildId}`);
+        const result = await db
+            .update(dbDiscordTable)
+            .set({ isInServer: false })
+            .where(eq(dbDiscordTable.guildId, guild.guildId))
+            .returning();
+
+        if (result) {
+            console.log(
+                `Successfully removed guild ${guild.guildId} from tracking.`,
+            );
+        } else {
+            console.error(
+                `Failed to remove guild ${guild.guildId} from tracking.`,
+            );
+        }
+    });
+
+    newGuilds.forEach(async (guildId) => {
+        console.log(`Adding new guild to tracking: ${guildId}`);
+        const result = await db
+            .insert(dbDiscordTable)
+            .values({
+                guildId,
+                allowedPublicSharing: false,
+                feedrUpdatesChannelId: null,
+                isInServer: true,
+                memberCount: 0,
+            })
+            .returning();
+
+        if (result) {
+            console.log(`Successfully added guild ${guildId} to tracking.`);
+        } else {
+            console.error(`Failed to add guild ${guildId} to tracking.`);
+        }
+    });
+}