feat(bot): add autocomplete to /untrack

Author: GalvinPython

src/commands.ts

@@ -26,6 +26,7 @@ import search from "./utils/youtube/search";
 import {
     checkIfGuildIsTrackingUserAlready,
     discordAddGuildTrackingUser,
+    discordGetAllTrackedInGuild,
 } from "./db/discord";
 import { Platform, YouTubeContentType } from "./types/types.d";
 import searchTwitch from "./utils/twitch/searchTwitch";
@@ -756,28 +757,14 @@ const commands: Record<string, Command> = {
     untrack: {
         data: {
             options: [
-                {
-                    name: "platform",
-                    description: "Select a supported platform to track",
-                    type: 3,
-                    required: true,
-                    choices: [
-                        {
-                            name: "Twitch",
-                            value: "twitch",
-                        },
-                        {
-                            name: "YouTube",
-                            value: "youtube",
-                        },
-                    ],
-                },
                 {
                     name: "user_id",
+                    // TODO: Searching
                     description:
-                        "Enter the YouTube/Twitch channel ID to stop tracking",
+                        "Select the channel or streamer to stop tracking. Searching is not supported, use the above options!",
                     type: 3,
                     required: true,
+                    autocomplete: true,
                 },
             ],
             name: "untrack",
@@ -924,6 +911,44 @@ const commands: Record<string, Command> = {
                     return;
             }
         },
+        autoComplete: async (interaction: AutocompleteInteraction) => {
+            const trackedChannels = await discordGetAllTrackedInGuild(
+                interaction.guildId as string,
+            );
+
+            console.dir(
+                { message: "Tracked channels:", data: trackedChannels },
+                { depth: null },
+            );
+
+            if (!trackedChannels || !trackedChannels.success) {
+                console.error(
+                    "An error occurred while trying to get the tracked channels in this guild!",
+                );
+                await interaction.respond([]);
+
+                return;
+            }
+
+            const trackedYouTubeChannels =
+                trackedChannels.data.youtubeSubscriptions;
+            const trackedTwitchChannels =
+                trackedChannels.data.twitchSubscriptions;
+
+            return await interaction.respond(
+                trackedYouTubeChannels
+                    .map((channel) => ({
+                        name: `YouTube: ${channel.youtubeChannel.youtubeChannelName} (${channel.youtubeChannel.youtubeChannelId}) | <#${channel.subscription.notificationChannelId}>`,
+                        value: String(channel.subscription.id),
+                    }))
+                    .concat(
+                        trackedTwitchChannels.map((channel) => ({
+                            name: `Twitch: ${channel.twitchChannel.twitchChannelName} (${channel.twitchChannel.twitchChannelId}) | <#${channel.subscription.notificationChannelId}>`,
+                            value: String(channel.subscription.id),
+                        })),
+                    ),
+            );
+        },
     },
     tracked: {
         data: {

src/db/discord.ts

@@ -7,6 +7,8 @@ import {
     dbGuildYouTubeSubscriptionsTable,
     dbGuildTwitchSubscriptionsTable,
     dbDiscordTable,
+    dbYouTubeTable,
+    dbTwitchTable,
 } from "./schema";
 
 export async function checkIfGuildIsTrackingUserAlready(
@@ -199,22 +201,66 @@ export async function discordGetAllTrackedInGuild(guildId: string): Promise<
     | {
           success: true;
           data: {
-              youtubeSubscriptions: (typeof dbGuildYouTubeSubscriptionsTable.$inferSelect)[];
-              twitchSubscriptions: (typeof dbGuildTwitchSubscriptionsTable.$inferSelect)[];
+              youtubeSubscriptions: {
+                  subscription: typeof dbGuildYouTubeSubscriptionsTable.$inferSelect;
+                  youtubeChannel: typeof dbYouTubeTable.$inferSelect;
+                  discord: typeof dbDiscordTable.$inferSelect;
+              }[];
+              twitchSubscriptions: {
+                  subscription: typeof dbGuildTwitchSubscriptionsTable.$inferSelect;
+                  twitchChannel: typeof dbTwitchTable.$inferSelect;
+                  discord: typeof dbDiscordTable.$inferSelect;
+              }[];
           };
       }
     | { success: false; data: null }
 > {
     try {
         const youtubeSubscriptions = await db
-            .select()
+            .select({
+                subscription: dbGuildYouTubeSubscriptionsTable,
+                youtubeChannel: dbYouTubeTable,
+                discord: dbDiscordTable,
+            })
             .from(dbGuildYouTubeSubscriptionsTable)
-            .where(eq(dbGuildYouTubeSubscriptionsTable.guildId, guildId));
+            .where(eq(dbGuildYouTubeSubscriptionsTable.guildId, guildId))
+            .innerJoin(
+                dbYouTubeTable,
+                eq(
+                    dbGuildYouTubeSubscriptionsTable.youtubeChannelId,
+                    dbYouTubeTable.youtubeChannelId,
+                ),
+            )
+            .innerJoin(
+                dbDiscordTable,
+                eq(
+                    dbGuildYouTubeSubscriptionsTable.guildId,
+                    dbDiscordTable.guildId,
+                ),
+            );
 
         const twitchSubscriptions = await db
-            .select()
+            .select({
+                subscription: dbGuildTwitchSubscriptionsTable,
+                twitchChannel: dbTwitchTable,
+                discord: dbDiscordTable,
+            })
             .from(dbGuildTwitchSubscriptionsTable)
-            .where(eq(dbGuildTwitchSubscriptionsTable.guildId, guildId));
+            .where(eq(dbGuildTwitchSubscriptionsTable.guildId, guildId))
+            .innerJoin(
+                dbTwitchTable,
+                eq(
+                    dbGuildTwitchSubscriptionsTable.twitchChannelId,
+                    dbTwitchTable.twitchChannelId,
+                ),
+            )
+            .innerJoin(
+                dbDiscordTable,
+                eq(
+                    dbGuildTwitchSubscriptionsTable.guildId,
+                    dbDiscordTable.guildId,
+                ),
+            );
 
         return {
             success: true,