feat(bot): add actual counting feature

ToastedDev · ToastedDev · commit 91033c057d75 · 2024-07-29T19:25:07.000+08:00
diff --git a/api/package.json b/api/package.json
@@ -5,14 +5,16 @@
   "scripts": {
     "dev": "BUN_CONFIG_NO_CLEAR_TERMINAL_ON_RELOAD=1 bun with-env bun --watch src/index.ts",
     "db:push": "bun with-env drizzle-kit push",
+    "db:studio": "bun with-env drizzle-kit studio",
     "with-env": "dotenv -e ../.env --"
   },
   "dependencies": {
     "@hono/trpc-server": "^0.3.2",
     "@trpc/server": "^10.45.2",
     "drizzle-orm": "^0.32.1",
     "hono": "^4.5.2",
-    "postgres": "^3.4.4"
+    "postgres": "^3.4.4",
+    "zod": "^3.23.8"
   },
   "devDependencies": {
     "@types/bun": "latest",
diff --git a/api/src/index.ts b/api/src/index.ts
@@ -1,6 +1,7 @@
 import { trpcServer } from "@hono/trpc-server";
 import { Hono } from "hono";
 import { appRouter } from "./router";
+import { createContext } from "./utils/trpc";
 
 const app = new Hono();
 
@@ -20,6 +21,7 @@ app.use(
   },
   trpcServer({
     router: appRouter,
+    createContext,
   }),
 );
 
diff --git a/api/src/router/channels.ts b/api/src/router/channels.ts
@@ -0,0 +1,104 @@
+import { z } from "zod";
+import { procedure, router } from "../utils/trpc";
+import { channels, guilds } from "../utils/db/schema";
+import { and, eq } from "drizzle-orm";
+import { TRPCError } from "@trpc/server";
+
+export const channelsRouter = router({
+  getChannels: procedure
+    .input(z.object({ guildId: z.string() }))
+    .query(async ({ ctx, input }) => {
+      if (
+        !(await ctx.db.query.guilds.findFirst({
+          where: eq(guilds.id, input.guildId),
+        }))
+      )
+        throw new TRPCError({
+          code: "NOT_FOUND",
+          message: "Guild not found",
+        });
+
+      return await ctx.db.query.channels.findMany({
+        where: eq(channels.guildId, input.guildId),
+      });
+    }),
+  addChannel: procedure
+    .input(
+      z.object({
+        channelId: z.string(),
+        guildId: z.string(),
+        name: z.string(),
+      }),
+    )
+    .mutation(async ({ ctx, input }) => {
+      if (
+        !(await ctx.db.query.guilds.findFirst({
+          where: eq(guilds.id, input.guildId),
+        }))
+      )
+        throw new TRPCError({
+          code: "NOT_FOUND",
+          message: "Guild not found",
+        });
+      if (
+        await ctx.db.query.channels.findFirst({
+          where: eq(channels.id, input.channelId),
+        })
+      )
+        throw new TRPCError({
+          code: "BAD_REQUEST",
+          message: "Channel already exists",
+        });
+
+      const createdChannels = await ctx.db
+        .insert(channels)
+        .values({
+          id: input.channelId,
+          guildId: input.guildId,
+          name: input.name,
+          count: 0,
+        })
+        .returning();
+      return createdChannels[0];
+    }),
+  setCount: procedure
+    .input(
+      z.object({
+        guildId: z.string(),
+        channelId: z.string(),
+        count: z.number(),
+      }),
+    )
+    .mutation(async ({ ctx, input }) => {
+      await ctx.db
+        .update(channels)
+        .set({ count: input.count })
+        .where(
+          and(
+            (eq(channels.id, input.channelId),
+            eq(channels.guildId, input.guildId)),
+          ),
+        );
+      return { success: true };
+    }),
+  updateLastUser: procedure
+    .input(
+      z.object({
+        channelId: z.string(),
+        guildId: z.string(),
+        userId: z.string(),
+      }),
+    )
+    .mutation(async ({ ctx, input }) => {
+      await ctx.db
+        .update(channels)
+        .set({ lastUserId: input.userId })
+        .where(
+          and(
+            (eq(channels.id, input.channelId),
+            eq(channels.guildId, input.guildId)),
+          ),
+        );
+      return { success: true };
+    }),
+});
diff --git a/api/src/router/guilds.ts b/api/src/router/guilds.ts
@@ -0,0 +1,18 @@
+import { z } from "zod";
+import { procedure, router } from "../utils/trpc";
+import { guilds } from "../utils/db/schema";
+
+export const guildsRouter = router({
+  createGuild: procedure
+    .input(z.object({ id: z.string(), name: z.string() }))
+    .mutation(async ({ ctx, input }) => {
+      const createdGuilds = await ctx.db
+        .insert(guilds)
+        .values({
+          id: input.id,
+          name: input.name,
+        })
+        .returning();
+      return createdGuilds[0];
+    }),
+});
diff --git a/api/src/router/index.ts b/api/src/router/index.ts
@@ -1,11 +1,11 @@
-import { db } from "../utils/db";
 import { procedure, router } from "../utils/trpc";
+import { channelsRouter } from "./channels";
+import { guildsRouter } from "./guilds";
 
 export const appRouter = router({
   greeting: procedure.query(() => "Hello from tRPC v10!"),
-  getGuilds: procedure.query(async () => {
-    return await db.query.guilds.findMany();
-  }),
+  channels: channelsRouter,
+  guilds: guildsRouter,
 });
 
 // Export only the type of a router!
diff --git a/api/src/utils/db/schema.ts b/api/src/utils/db/schema.ts
@@ -1,6 +1,14 @@
-import { pgTable, text } from "drizzle-orm/pg-core";
+import { integer, pgTable, text } from "drizzle-orm/pg-core";
 
 export const guilds = pgTable("guilds", {
   id: text("id").primaryKey(),
   name: text("name"),
 });
+
+export const channels = pgTable("channels", {
+  id: text("id").primaryKey(),
+  name: text("name"),
+  guildId: text("guild_id").references(() => guilds.id),
+  count: integer("count").default(0),
+  lastUserId: text("last_user_id"),
+});
diff --git a/api/src/utils/trpc.ts b/api/src/utils/trpc.ts
@@ -1,6 +1,11 @@
 import { initTRPC } from "@trpc/server";
+import { db } from "./db";
 
-const t = initTRPC.create();
+export const createContext = async () => {
+  return { db };
+};
+
+const t = initTRPC.context<typeof createContext>().create();
 
 export const router = t.router;
 export const procedure = t.procedure;
diff --git a/bot/src/commands/configuration/channels.ts b/bot/src/commands/configuration/channels.ts
@@ -0,0 +1,63 @@
+import { ChannelType, SlashCommandBuilder } from "discord.js";
+import type { Command } from "../../structures/command";
+import { api } from "../../utils/trpc";
+import { TRPCClientError } from "@trpc/client";
+
+export default {
+  data: new SlashCommandBuilder()
+    .setName("channels")
+    .setDescription("Manage counting channels for this server.")
+    .addSubcommand((subcommand) =>
+      subcommand
+        .setName("add")
+        .setDescription("Add a counting channel.")
+        .addChannelOption((option) =>
+          option
+            .setName("channel")
+            .setDescription("The channel to add.")
+            .addChannelTypes(ChannelType.GuildText)
+            .setRequired(true),
+        ),
+    ),
+  run: async ({ interaction }) => {
+    await interaction.deferReply({
+      ephemeral: true,
+    });
+
+    const subcommand = interaction.options.getSubcommand();
+    switch (subcommand) {
+      case "add": {
+        const channel = interaction.options.getChannel("channel", true);
+        try {
+          await api.channels.addChannel.mutate({
+            channelId: channel.id,
+            name: channel.name,
+            guildId: interaction.guild.id,
+          });
+          return interaction.followUp(
+            `Added ${channel} as a counting channel.`,
+          );
+        } catch (err) {
+          if (err instanceof TRPCClientError) {
+            if (err.message === "Guild not found") {
+              await api.guilds.createGuild.mutate({
+                id: interaction.guild.id,
+                name: interaction.guild.name,
+              });
+              await api.channels.addChannel.mutate({
+                channelId: channel.id,
+                name: channel.name,
+                guildId: interaction.guild.id,
+              });
+              return interaction.followUp(
+                `Added ${channel} as a counting channel.`,
+              );
+            } else {
+              return interaction.followUp(err.message);
+            }
+          }
+        }
+      }
+    }
+  },
+} satisfies Command;
diff --git a/bot/src/features/counting.ts b/bot/src/features/counting.ts
@@ -0,0 +1,49 @@
+import { TRPCClientError } from "@trpc/client";
+import type { BotClient } from "../structures/client";
+import { api } from "../utils/trpc";
+
+const isNumber = (str: string) => /^\d+$/.test(str);
+
+function stripCommas(str: string) {
+  return str.replace(/,/g, "");
+}
+
+export default (client: BotClient) => {
+  client.on("messageCreate", async (message) => {
+    if (message.author.bot || !message.guild) return;
+
+    try {
+      // TODO: cache all api calls to avoid spamming the api
+      const channels = await api.channels.getChannels.query({
+        guildId: message.guild.id,
+      });
+      const currentChannel = channels.find(
+        (channel) => channel.id === message.channel.id,
+      );
+      if (!channels.length || !currentChannel) return;
+
+      const messageSplit = message.content.split(/[ :\n]+/);
+      const messageNumberString = stripCommas(messageSplit[0]);
+      if (!isNumber(messageNumberString)) return message.delete();
+
+      const messageNumber = parseInt(messageNumberString, 10);
+      const nextCount = (currentChannel.count ?? 0) + 1;
+      if (nextCount !== messageNumber) return message.delete();
+
+      await api.channels.setCount.mutate({
+        channelId: currentChannel.id,
+        guildId: message.guild.id,
+        count: nextCount,
+      });
+      await api.channels.updateLastUser.mutate({
+        channelId: currentChannel.id,
+        guildId: message.guild.id,
+        userId: message.author.id,
+      });
+    } catch (err) {
+      if (err instanceof TRPCClientError && err.message === "Guild not found")
+        return;
+      console.error(err);
+    }
+  });
+};
diff --git a/bot/src/structures/client.ts b/bot/src/structures/client.ts
@@ -22,6 +22,7 @@ export class BotClient<Ready extends boolean = boolean> extends Client<Ready> {
   register() {
     this._registerCommands();
     this._registerEvents();
+    this._registerFeatures();
   }
 
   private async _registerCommands() {
@@ -54,4 +55,14 @@ export class BotClient<Ready extends boolean = boolean> extends Client<Ready> {
       this.on(event.name, event.run.bind(null, this));
     }
   }
+
+  private async _registerFeatures() {
+    const featureFiles = await readdir(join(process.cwd(), "src/features"));
+    for (const file of featureFiles) {
+      const feature = await import(`../features/${file}`).then(
+        (x) => x.default,
+      );
+      feature(this);
+    }
+  }
 }
diff --git a/bun.lockb b/bun.lockb
diff --git a/package.json b/package.json
@@ -8,7 +8,8 @@
   "scripts": {
     "dev": "turbo run dev",
     "build": "turbo run build",
-    "db:push": "cd api && bun db:push"
+    "db:push": "cd api && bun db:push",
+    "db:studio": "cd api && bun db:studio"
   },
   "author": "ToastedToast <hey@toasted.dev>",
   "license": "MIT",

Original file line number	Diff line number	Diff line change
`@@ -22,6 +22,7 @@ export class BotClient<Ready extends boolean = boolean> extends Client<Ready> {`
`22`	`22`	`register() {`
`23`	`23`	`this._registerCommands();`
`24`	`24`	`this._registerEvents();`
	`25`	`+ this._registerFeatures();`
`25`	`26`	`}`
`26`	`27`
`27`	`28`	`private async _registerCommands() {`
`@@ -54,4 +55,14 @@ export class BotClient<Ready extends boolean = boolean> extends Client<Ready> {`
`54`	`55`	`this.on(event.name, event.run.bind(null, this));`
`55`	`56`	`}`
`56`	`57`	`}`
	`58`	`+`
	`59`	`+ private async _registerFeatures() {`
	`60`	`+ const featureFiles = await readdir(join(process.cwd(), "src/features"));`
	`61`	`+ for (const file of featureFiles) {`
	`62`	+ const feature = await import(`../features/${file}`).then(
	`63`	`+ (x) => x.default,`
	`64`	`+ );`
	`65`	`+ feature(this);`
	`66`	`+ }`
	`67`	`+ }`
`57`	`68`	`}`