feat(twitch): wow twitch is back

Author: GalvinPython

src/db/schema.ts

@@ -1,15 +1,26 @@
 // To make it easier to work with the database, disable prettier and some eslint rules for this file
 /* eslint-disable no-inline-comments */
 /* eslint-disable prettier/prettier */
-import { pgTable, serial, text, boolean, timestamp, decimal, unique, index, pgEnum, jsonb, integer } from "drizzle-orm/pg-core";
+import { sql } from "drizzle-orm";
+import { pgTable, serial, text, boolean, timestamp, decimal, unique, index, pgEnum, jsonb, integer, check } from "drizzle-orm/pg-core";
 
 export const dbDiscordTable = pgTable("discord", {
     guildId: text("guild_id").primaryKey(),
     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),
-});
+    isDm: boolean("is_dm").notNull().default(false),
+}, (table) => [
+    check("discord_is_dm_constraint",
+        sql`NOT ${table.isDm} OR (
+            ${table.allowedPublicSharing} = false AND
+            ${table.feedrUpdatesChannelId} = ${table.guildId} AND
+            ${table.isInServer} = true AND
+            ${table.memberCount} = 1
+        )`
+    )
+]);
 
 export const dbBlueskyTable = pgTable("bluesky", {
     blueskyUserId: text("bluesky_user_id").primaryKey(),

src/db/twitch.ts

@@ -85,4 +85,4 @@ export async function twitchUpdateIsLive(
 
         return { success: false };
     }
-}
+}

src/events/ready.ts

@@ -1,12 +1,12 @@
 import { Events } from "discord.js";
-import { CronJob } from "cron";
+// import { CronJob } from "cron";
 
 import client from "../index";
 import { config } from "../config";
-// import { checkIfStreamersAreLive } from "../utils/twitch/checkIfStreamerIsLive";
-import { cronUpdateBotInfo } from "../utils/cronJobs";
+// import { cronUpdateBotInfo } from "../utils/cronJobs";
 import sendLatestUploads from "../utils/youtube/sendLatestUploads";
 import fetchLatestUploads from "../utils/youtube/fetchLatestUploads";
+import { checkIfStreamersAreLive } from "../utils/twitch/checkIfStreamerIsLive";
 
 // Log into the bot
 client.once(Events.ClientReady, async (bot) => {
@@ -24,8 +24,6 @@ client.once(Events.ClientReady, async (bot) => {
     sendLatestUploads();
     setInterval(sendLatestUploads, config.updateIntervalYouTube as number);
 
-    // TODO: Twitch integration is not ready yet
-    // One at a time
-    // checkIfStreamersAreLive();
-    // setInterval(checkIfStreamersAreLive, config.updateIntervalTwitch as number);
+    checkIfStreamersAreLive();
+    setInterval(checkIfStreamersAreLive, config.updateIntervalTwitch as number);
 });

src/utils/twitch/checkIfStreamerIsLive.ts

@@ -2,6 +2,12 @@ import type { TextChannel } from "discord.js";
 
 import { env } from "../../config";
 import client from "../..";
+import {
+    dbTwitchGetAllChannelsToTrack,
+    twitchUpdateIsLive,
+} from "../../db/twitch";
+import { discordGetAllGuildsTrackingChannel } from "../../db/discord";
+import { Platform } from "../../types/types.d";
 
 import { twitchToken } from "./auth";
 import { getStreamerName } from "./getStreamerName";
@@ -48,22 +54,19 @@ export async function checkIfStreamersAreLive(): Promise<void> {
         return;
     }
 
-    const allStreamerIds = await twitchGetAllChannelsToTrack();
+    const allStreamerIds = await dbTwitchGetAllChannelsToTrack();
     const chunkSize = 100;
     const chunks = [];
 
-    for (let i = 0; i < allStreamerIds.length; i += chunkSize) {
-        const chunk = allStreamerIds.slice(i, i + chunkSize);
+    for (let i = 0; i < allStreamerIds.data.length; i += chunkSize) {
+        const chunk = allStreamerIds.data.slice(i, i + chunkSize);
 
         chunks.push(chunk);
     }
 
     for (const chunk of chunks) {
         const urlQueries = chunk
-            .map(
-                (streamerId: dbTwitch) =>
-                    `user_id=${streamerId.twitch_channel_id}`,
-            )
+            .map((streamerId) => `user_id=${streamerId.twitchChannelId}`)
             .join("&");
         const res = await fetch(
             `https://api.twitch.tv/helix/streams?${urlQueries}`,
@@ -89,51 +92,53 @@ export async function checkIfStreamersAreLive(): Promise<void> {
 
         for (const streamerId of chunk) {
             const isLive = allLiveStreamers.includes(
-                streamerId.twitch_channel_id,
+                streamerId.twitchChannelId,
             );
-            const needsUpdate = isLive !== Boolean(streamerId.is_live);
+            const needsUpdate =
+                isLive !== Boolean(streamerId.twitchChannelIsLive);
 
             console.log(
-                `[Twitch] ${streamerId.twitch_channel_id} is live:`,
+                `[Twitch] ${streamerId.twitchChannelId} is live:`,
                 isLive,
                 ". Was live:",
-                Boolean(streamerId.is_live),
+                Boolean(streamerId.twitchChannelIsLive),
                 ". Needs update:",
                 needsUpdate,
             );
 
             if (needsUpdate) {
                 // Update the database
                 console.log(
-                    `Updating ${streamerId.twitch_channel_id} to be ${isLive ? "live" : "offline"}`,
+                    `Updating ${streamerId.twitchChannelId} to be ${isLive ? "live" : "offline"}`,
                 );
-                await twitchUpdateIsLive(streamerId.twitch_channel_id, isLive);
+                await twitchUpdateIsLive(streamerId.twitchChannelId, isLive);
 
                 if (isLive) {
                     // Get the streamer's name
                     const streamerName = await getStreamerName(
-                        streamerId.twitch_channel_id,
+                        streamerId.twitchChannelId,
                     );
 
                     // Get all guilds that are tracking this streamer
                     const guildsTrackingStreamer =
-                        await twitchGetGuildsTrackingChannel(
-                            streamerId.twitch_channel_id,
+                        await discordGetAllGuildsTrackingChannel(
+                            Platform.Twitch,
+                            streamerId.twitchChannelId,
                         );
 
-                    for (const guild of guildsTrackingStreamer) {
+                    for (const guild of guildsTrackingStreamer.data) {
                         // Send a message to the channel
                         const channel = await client.channels.fetch(
-                            guild.guild_channel_id,
+                            guild.guildId,
                         );
 
                         await (channel as TextChannel).send(
-                            `${guild.guild_ping_role ? `<@&${guild.guild_ping_role}>` : ""} ${streamerName} is now live <https://twitch.tv/${streamerName}>!`,
+                            `${guild.notificationRoleId ? `<@&${guild.notificationRoleId}>` : ""} ${streamerName} is now live <https://twitch.tv/${streamerName}>!`,
                         );
                     }
                 } else {
                     console.log(
-                        `[Twitch] ${streamerId.twitch_channel_id} is offline!`,
+                        `[Twitch] ${streamerId.twitchChannelId} is offline!`,
                     );
                 }
             }