Added Warn and Ban Commands, Added Logging, and Much More

src/db/db.ts

@@ -0,0 +1,97 @@
+import pkg from 'pg';
+import { drizzle } from 'drizzle-orm/node-postgres';
+import * as schema from './schema.js';
+import { eq } from 'drizzle-orm';
+import { loadConfig } from '../util/configLoader.js';
+
+const { Pool } = pkg;
+const config = loadConfig();
+
+const dbPool = new Pool({
+  connectionString: config.dbConnectionString,
+  ssl: true,
+});
+export const db = drizzle({ client: dbPool, schema });
+
+export async function getAllMembers() {
+  return await db
+    .select()
+    .from(schema.memberTable)
+    .where(eq(schema.memberTable.currentlyInServer, true));
+}
+
+export async function setMembers(nonBotMembers: any) {
+  nonBotMembers.forEach(async (member: any) => {
+    const memberExists = await db
+      .select()
+      .from(schema.memberTable)
+      .where(eq(schema.memberTable.discordId, member.user.id));
+    if (memberExists.length > 0) {
+      await db
+        .update(schema.memberTable)
+        .set({ discordUsername: member.user.username })
+        .where(eq(schema.memberTable.discordId, member.user.id));
+    } else {
+      const members: typeof schema.memberTable.$inferInsert = {
+        discordId: member.user.id,
+        discordUsername: member.user.username,
+      };
+      await db.insert(schema.memberTable).values(members);
+    }
+  });
+}
+
+export async function getMember(discordId: string) {
+  return await db.query.memberTable.findFirst({
+    where: eq(schema.memberTable.discordId, discordId),
+    with: {
+      moderations: true,
+    },
+  });
+}
+
+export async function updateMember({
+  discordId,
+  discordUsername,
+  currentlyInServer,
+  currentlyBanned,
+}: schema.memberTableTypes) {
+  return await db
+    .update(schema.memberTable)
+    .set({
+      discordUsername,
+      currentlyInServer,
+      currentlyBanned,
+    })
+    .where(eq(schema.memberTable.discordId, discordId));
+}
+
+export async function updateMemberModerationHistory({
+  discordId,
+  moderatorDiscordId,
+  action,
+  reason,
+  duration,
+  createdAt,
+  expiresAt,
+  active,
+}: schema.moderationTableTypes) {
+  const moderationEntry = {
+    discordId,
+    moderatorDiscordId,
+    action,
+    reason,
+    duration,
+    createdAt,
+    expiresAt,
+    active,
+  };
+  return await db.insert(schema.moderationTable).values(moderationEntry);
+}
+
+export async function getMemberModerationHistory(discordId: string) {
+  return await db
+    .select()
+    .from(schema.moderationTable)
+    .where(eq(schema.moderationTable.discordId, discordId));
+}

src/db/schema.ts

@@ -1,9 +1,63 @@
-import { integer, pgTable, varchar } from 'drizzle-orm/pg-core';
+import {
+  boolean,
+  integer,
+  pgTable,
+  timestamp,
+  varchar,
+} from 'drizzle-orm/pg-core';
+import { relations } from 'drizzle-orm';
+
+export interface memberTableTypes {
+  id?: number;
+  discordId: string;
+  discordUsername?: string;
+  currentlyInServer?: boolean;
+  currentlyBanned?: boolean;
+  currentlyMuted?: boolean;
+}
 
 export const memberTable = pgTable('members', {
   id: integer().primaryKey().generatedAlwaysAsIdentity(),
   discordId: varchar('discord_id').notNull().unique(),
   discordUsername: varchar('discord_username').notNull(),
-  numberOfWarnings: integer('number_warnings').notNull().default(0),
-  numberOfBans: integer('number_bans').notNull().default(0),
+  currentlyInServer: boolean('currently_in_server').notNull().default(true),
+  currentlyBanned: boolean('currently_banned').notNull().default(false),
+  currentlyMuted: boolean('currently_muted').notNull().default(false),
 });
+
+export interface moderationTableTypes {
+  id?: number;
+  discordId: string;
+  moderatorDiscordId: string;
+  action: 'warning' | 'mute' | 'kick' | 'ban';
+  reason: string;
+  duration: string;
+  createdAt?: Date;
+  expiresAt?: Date;
+  active?: boolean;
+}
+
+export const moderationTable = pgTable('moderations', {
+  id: integer().primaryKey().generatedAlwaysAsIdentity(),
+  discordId: varchar('discord_id')
+    .notNull()
+    .references(() => memberTable.discordId, { onDelete: 'cascade' }),
+  moderatorDiscordId: varchar('moderator_discord_id').notNull(),
+  action: varchar('action').notNull(),
+  reason: varchar('reason').notNull().default(''),
+  duration: varchar('duration').default(''),
+  createdAt: timestamp('created_at').notNull().defaultNow(),
+  expiresAt: timestamp('expires_at'),
+  active: boolean('active').notNull().default(true),
+});
+
+export const memberRelations = relations(memberTable, ({ many }) => ({
+  moderations: many(moderationTable),
+}));
+
+export const moderationRelations = relations(moderationTable, ({ one }) => ({
+  member: one(memberTable, {
+    fields: [moderationTable.discordId],
+    references: [memberTable.discordId],
+  }),
+}));