feat: add analytics and operations modules for user and moderation action management

Author: wiktoriavh

src/database/analytics.ts

@@ -0,0 +1,131 @@
+import {
+  ActionStatus,
+  type ActionType,
+  type ModerationAction,
+} from "../../generated/prisma/index.js";
+import { prisma } from "./operations.js";
+
+export async function getUserActionStats(discordId: string) {
+  const user = await prisma.user.findUnique({
+    where: { discordId },
+    include: {
+      actionsReceived: {
+        where: {
+          status: { in: [ActionStatus.ACTIVE, ActionStatus.EXPIRED] },
+        },
+      },
+    },
+  });
+
+  if (!user) {
+    return null;
+  }
+
+  const actionsByType = user.actionsReceived.reduce(
+    (acc, action) => {
+      acc[action.type] = (acc[action.type] || 0) + 1;
+      return acc;
+    },
+    {} as Record<ActionType, number>
+  );
+
+  return {
+    discordId: user.discordId,
+    totalActions: user.actionsReceived.length,
+    actionsByType,
+  };
+}
+
+export async function getModeratorStats(discordId: string, days = 30) {
+  const user = await prisma.user.findUnique({
+    where: { discordId },
+  });
+
+  if (!user) {
+    return null;
+  }
+
+  const since = new Date(Date.now() - days * 24 * 60 * 60 * 1000);
+
+  const actions = await prisma.moderationAction.findMany({
+    where: {
+      moderatorId: user.id,
+      createdAt: { gte: since },
+      status: { not: ActionStatus.REMOVED_BY_ERROR },
+    },
+  });
+
+  const actionsByType = actions.reduce(
+    (acc, action) => {
+      acc[action.type] = (acc[action.type] || 0) + 1;
+      return acc;
+    },
+    {} as Record<ActionType, number>
+  );
+
+  return {
+    discordId: user.discordId,
+    totalActions: actions.length,
+    actionsByType,
+    period: `${days} days`,
+  };
+}
+
+export async function getRecentActions(limit = 20) {
+  return await prisma.moderationAction.findMany({
+    include: {
+      target: true,
+      moderator: true,
+    },
+    orderBy: { createdAt: "desc" },
+    take: limit,
+  });
+}
+
+export async function findRepeatOffenders(minActions = 3) {
+  const actions = await prisma.moderationAction.findMany({
+    where: {
+      status: { in: [ActionStatus.ACTIVE, ActionStatus.EXPIRED] },
+    },
+    include: {
+      target: true,
+    },
+  });
+
+  const userActionCounts = actions.reduce(
+    (acc, action) => {
+      const discordId = action.target.discordId;
+      if (!acc[discordId]) {
+        acc[discordId] = { discordId, count: 0, actions: [] };
+      }
+      acc[discordId].count++;
+      acc[discordId].actions.push(action);
+      return acc;
+    },
+    {} as Record<string, { discordId: string; count: number; actions: ModerationAction[] }>
+  );
+
+  return Object.values(userActionCounts)
+    .filter((item) => item.count >= minActions)
+    .sort((a, b) => b.count - a.count);
+}
+
+export async function getActionsByType(actionType: ActionType, limit = 50) {
+  return await prisma.moderationAction.findMany({
+    where: { type: actionType },
+    include: {
+      target: true,
+      moderator: true,
+    },
+    orderBy: { createdAt: "desc" },
+    take: limit,
+  });
+}
+
+export async function getTotalActionCount() {
+  return await prisma.moderationAction.count({
+    where: {
+      status: { not: ActionStatus.REMOVED_BY_ERROR },
+    },
+  });
+}

src/database/operations.ts

@@ -0,0 +1,150 @@
+import { ActionStatus, type ActionType, PrismaClient } from "../../generated/prisma/index.js";
+
+export const prisma = new PrismaClient();
+
+// Connect to database and verify connection
+export async function connectDatabase() {
+  try {
+    await prisma.$connect();
+    // Test query to verify connection
+    await prisma.user.findFirst();
+    console.log("✅ Database connected successfully");
+  } catch (error) {
+    console.error("❌ Database connection failed:", error);
+    throw error;
+  }
+}
+
+// Disconnect from database
+export async function disconnectDatabase() {
+  await prisma.$disconnect();
+  console.log("Database disconnected");
+}
+
+// User operations - only Discord ID needed
+export async function upsertUser(discordId: string) {
+  return await prisma.user.upsert({
+    where: { discordId },
+    update: {},
+    create: { discordId },
+  });
+}
+
+export async function getUserByDiscordId(discordId: string) {
+  return await prisma.user.findUnique({
+    where: { discordId },
+  });
+}
+
+// Moderation action operations
+type CreateActionParams = {
+  type: ActionType;
+  targetDiscordId: string;
+  moderatorDiscordId: string;
+  reason?: string;
+  duration?: number;
+};
+
+export async function createModerationAction(params: CreateActionParams) {
+  // Ensure both users exist
+  const target = await upsertUser(params.targetDiscordId);
+  const moderator = await upsertUser(params.moderatorDiscordId);
+
+  // Calculate expiry for timed actions
+  const expiresAt = params.duration ? new Date(Date.now() + params.duration * 1000) : null;
+
+  return await prisma.moderationAction.create({
+    data: {
+      type: params.type,
+      reason: params.reason,
+      duration: params.duration,
+      targetId: target.id,
+      moderatorId: moderator.id,
+      expiresAt,
+    },
+    include: {
+      target: true,
+      moderator: true,
+    },
+  });
+}
+
+export async function removeActionByError(
+  actionId: number,
+  removedByDiscordId: string,
+  reason: string
+) {
+  const removedBy = await upsertUser(removedByDiscordId);
+
+  // Mark original action as removed
+  const originalAction = await prisma.moderationAction.update({
+    where: { id: actionId },
+    data: { status: ActionStatus.REMOVED_BY_ERROR },
+  });
+
+  // Create correction record
+  return await prisma.moderationAction.create({
+    data: {
+      type: originalAction.type,
+      status: ActionStatus.REMOVED_BY_ERROR,
+      reason: `Correction: ${reason}`,
+      targetId: originalAction.targetId,
+      moderatorId: removedBy.id,
+      parentActionId: originalAction.id,
+    },
+    include: {
+      parentAction: true,
+    },
+  });
+}
+
+export async function getUserActions(discordId: string, limit = 50) {
+  const user = await getUserByDiscordId(discordId);
+  if (!user) {
+    return [];
+  }
+
+  return await prisma.moderationAction.findMany({
+    where: { targetId: user.id },
+    include: {
+      moderator: true,
+    },
+    orderBy: { createdAt: "desc" },
+    take: limit,
+  });
+}
+
+export async function getActiveActions(discordId: string) {
+  const user = await getUserByDiscordId(discordId);
+  if (!user) {
+    return [];
+  }
+
+  return await prisma.moderationAction.findMany({
+    where: {
+      targetId: user.id,
+      status: ActionStatus.ACTIVE,
+    },
+    include: {
+      moderator: true,
+    },
+  });
+}
+
+export async function getActionById(actionId: number) {
+  return await prisma.moderationAction.findUnique({
+    where: { id: actionId },
+    include: {
+      target: true,
+      moderator: true,
+      parentAction: true,
+    },
+  });
+}
+
+export async function updateActionStatus(actionId: number, status: ActionStatus) {
+  return await prisma.moderationAction.update({
+    where: { id: actionId },
+    data: { status },
+  });
+}