Harden analytics pages against missing tables and RSC dynamic imports.

Co-authored-by: Cursor <[email protected]>

prisma/schema.prisma

@@ -698,9 +698,9 @@ model LogsShopPurchases {
   catalogItemId   Int? @map("catalog_item_id")
   itemIds         String? @db.Text @map("item_ids")
   catalogName     String? @db.VarChar(255) @map("catalog_name")
-  costCredits     Int?
+  costCredits     Int? @map("cost_credits")
-  costPoints      Int?
+  costPoints      Int? @map("cost_points")
-  pointsType      Int?
+  pointsType      Int? @map("points_type")
   amount          Int?
 
   @@map("logs_shop_purchases")

src/app/admin/analytics/activity/page.tsx

@@ -5,88 +5,161 @@ import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
 import { canAccess, getAdminContext, PERMS } from "@/lib/permissions";
 import { prisma } from "@/lib/prisma";
 
-async function getActivityData() {
+type DayRow = {
+	label: string;
+	chats: number;
+	commands: number;
+	bans: number;
+	registrations: number;
+};
+
+type ActivityData = {
+	dailyData: DayRow[];
+	weekChats: number;
+	weekCommands: number;
+	weekBans: number;
+	weekRegistrations: number;
+	topChatters: { userId: number; username: string; messages: number }[];
+};
+
+async function safeCount(fn: () => Promise<number>): Promise<number> {
+	try {
+		return await fn();
+	} catch {
+		return 0;
+	}
+}
+
+async function safeRawCount(sql: Promise<{ count: bigint }[]>): Promise<number> {
+	try {
+		const rows = await sql;
+		return Number(rows[0]?.count ?? 0);
+	} catch {
+		return 0;
+	}
+}
+
+async function getActivityData(): Promise<ActivityData> {
 	const now = Math.floor(Date.now() / 1000);
 	const todayStart = now - (now % 86400);
 	const weekAgo = now - 7 * 86400;
-
-	// Daily activity breakdown — 4 GROUP BY queries instead of 28 sequential queries
 	const rangeStart = todayStart - 6 * 86400;
-	const [chatRows, cmdRows, banRows, regRows] = await Promise.all([
-		prisma.$queryRaw<{ day_bucket: bigint; count: bigint }[]>`
-      SELECT FLOOR(timestamp / 86400) AS day_bucket, COUNT(*) AS count
-      FROM chatlogs_room WHERE timestamp >= ${rangeStart} GROUP BY day_bucket`,
-		prisma.$queryRaw<{ day_bucket: bigint; count: bigint }[]>`
-      SELECT FLOOR(timestamp / 86400) AS day_bucket, COUNT(*) AS count
-      FROM commandlogs WHERE timestamp >= ${rangeStart} GROUP BY day_bucket`,
-		prisma.$queryRaw<{ day_bucket: bigint; count: bigint }[]>`
-      SELECT FLOOR(timestamp / 86400) AS day_bucket, COUNT(*) AS count
-      FROM bans WHERE timestamp >= ${rangeStart} GROUP BY day_bucket`,
-		prisma.$queryRaw<{ day_bucket: bigint; count: bigint }[]>`
-      SELECT FLOOR(account_created / 86400) AS day_bucket, COUNT(*) AS count
-      FROM users WHERE account_created >= ${rangeStart} GROUP BY day_bucket`,
-	]);
-	const toMap = (rows: { day_bucket: bigint; count: bigint }[]) =>
-		new Map(rows.map((r) => [Number(r.day_bucket), Number(r.count)]));
-	const chatMap = toMap(chatRows);
-	const cmdMap = toMap(cmdRows);
-	const banMap = toMap(banRows);
-	const regMap = toMap(regRows);
 
-	const dailyData = [];
+	const emptyDays: DayRow[] = [];
 	for (let i = 6; i >= 0; i--) {
 		const dayStart = todayStart - i * 86400;
-		const bucket = Math.floor(dayStart / 86400);
 		const date = new Date(dayStart * 1000);
-		dailyData.push({
+		emptyDays.push({
 			label: date.toLocaleDateString("en", {
 				weekday: "short",
 				month: "short",
 				day: "numeric",
 			}),
+			chats: 0,
+			commands: 0,
+			bans: 0,
+			registrations: 0,
+		});
+	}
+
+	const toMap = (rows: { day_bucket: bigint; count: bigint }[]) =>
+		new Map(rows.map((r) => [Number(r.day_bucket), Number(r.count)]));
+
+	let chatMap = new Map<number, number>();
+	let cmdMap = new Map<number, number>();
+	let banMap = new Map<number, number>();
+	let regMap = new Map<number, number>();
+
+	try {
+		const [chatRows, cmdRows, banRows, regRows] = await Promise.all([
+			prisma.$queryRaw<{ day_bucket: bigint; count: bigint }[]>`
+        SELECT FLOOR(timestamp / 86400) AS day_bucket, COUNT(*) AS count
+        FROM chatlogs_room WHERE timestamp >= ${rangeStart} GROUP BY day_bucket`.catch(
+				() => [],
+			),
+			prisma.$queryRaw<{ day_bucket: bigint; count: bigint }[]>`
+        SELECT FLOOR(timestamp / 86400) AS day_bucket, COUNT(*) AS count
+        FROM commandlogs WHERE timestamp >= ${rangeStart} GROUP BY day_bucket`.catch(
+				() => [],
+			),
+			prisma.$queryRaw<{ day_bucket: bigint; count: bigint }[]>`
+        SELECT FLOOR(timestamp / 86400) AS day_bucket, COUNT(*) AS count
+        FROM bans WHERE timestamp >= ${rangeStart} GROUP BY day_bucket`.catch(
+				() => [],
+			),
+			prisma.$queryRaw<{ day_bucket: bigint; count: bigint }[]>`
+        SELECT FLOOR(account_created / 86400) AS day_bucket, COUNT(*) AS count
+        FROM users WHERE account_created >= ${rangeStart} GROUP BY day_bucket`.catch(
+				() => [],
+			),
+		]);
+		chatMap = toMap(chatRows);
+		cmdMap = toMap(cmdRows);
+		banMap = toMap(banRows);
+		regMap = toMap(regRows);
+	} catch {
+		/* keep empty maps */
+	}
+
+	const dailyData = emptyDays.map((day, idx) => {
+		const dayStart = todayStart - (6 - idx) * 86400;
+		const bucket = Math.floor(dayStart / 86400);
+		return {
+			...day,
 			chats: chatMap.get(bucket) ?? 0,
 			commands: cmdMap.get(bucket) ?? 0,
 			bans: banMap.get(bucket) ?? 0,
 			registrations: regMap.get(bucket) ?? 0,
+		};
 	});
-	}
 
-	// Totals
+	const [weekChats, weekCommands, weekBans, weekRegistrations] =
-	const [weekChatRows, weekCommandRows, weekBans, weekRegistrations] =
 		await Promise.all([
-			prisma.$queryRaw<
+			safeRawCount(
-				{ count: bigint }[]
+				prisma.$queryRaw<{ count: bigint }[]>`
-			>`SELECT COUNT(*) AS count FROM chatlogs_room WHERE timestamp >= ${weekAgo}`,
+          SELECT COUNT(*) AS count FROM chatlogs_room WHERE timestamp >= ${weekAgo}`,
-			prisma.$queryRaw<
+			),
-				{ count: bigint }[]
+			safeRawCount(
-			>`SELECT COUNT(*) AS count FROM commandlogs WHERE timestamp >= ${weekAgo}`,
+				prisma.$queryRaw<{ count: bigint }[]>`
+          SELECT COUNT(*) AS count FROM commandlogs WHERE timestamp >= ${weekAgo}`,
+			),
+			safeCount(() =>
 				prisma.ban.count({ where: { timestamp: { gte: weekAgo } } }),
+			),
+			safeCount(() =>
 				prisma.user.count({ where: { accountCreated: { gte: weekAgo } } }),
+			),
 		]);
-	const weekChats = Number(weekChatRows[0]?.count ?? 0);
-	const weekCommands = Number(weekCommandRows[0]?.count ?? 0);
 
-	// Most active users (by chat messages)
+	let topChatters: ActivityData["topChatters"] = [];
-	const topChatters = await prisma.$queryRaw<
+	try {
+		const rows = await prisma.$queryRaw<
 			{ userId: number; messages: bigint }[]
 		>`
       SELECT user_from_id AS userId, COUNT(*) AS messages
       FROM chatlogs_room WHERE timestamp >= ${weekAgo}
       GROUP BY user_from_id ORDER BY messages DESC LIMIT 10
     `;
-
+		const userIds = rows.map((c) => Number(c.userId)).filter((n) => n > 0);
-	const userIds = topChatters.map((c) => c.userId);
+		const users =
-	const users = await prisma.user.findMany({
+			userIds.length > 0
+				? await prisma.user.findMany({
 						where: { id: { in: userIds } },
 						select: { id: true, username: true },
-	});
+					})
+				: [];
 		const userMap = new Map(users.map((u) => [u.id, u.username]));
-
+		topChatters = rows.map((c) => {
-	const topChattersWithNames = topChatters.map((c) => ({
+			const userId = Number(c.userId);
-		userId: c.userId,
+			return {
-		username: userMap.get(c.userId) ?? `User #${c.userId}`,
+				userId,
+				username: userMap.get(userId) ?? `User #${userId}`,
 				messages: Number(c.messages),
-	}));
+			};
+		});
+	} catch {
+		topChatters = [];
+	}
 
 	return {
 		dailyData,
@@ -94,7 +167,7 @@ async function getActivityData() {
 		weekCommands,
 		weekBans,
 		weekRegistrations,
-		topChatters: topChattersWithNames,
+		topChatters,
 	};
 }
 
@@ -136,7 +209,6 @@ export default async function ActivityPage() {
 			</div>
 
 			<div className="grid gap-6 md:grid-cols-2">
-				{/* Daily breakdown table */}
 				<Card>
 					<CardHeader>
 						<CardTitle>Daily Breakdown (7 days)</CardTitle>
@@ -175,7 +247,6 @@ export default async function ActivityPage() {
 					</CardContent>
 				</Card>
 
-				{/* Top chatters */}
 				<Card>
 					<CardHeader>
 						<CardTitle>Most Active Users (7 days)</CardTitle>

src/app/admin/analytics/economy/page.tsx

@@ -1,54 +1,108 @@
 import { ArrowLeftRight, Coins, TrendingDown, TrendingUp } from "lucide-react";
-import dynamic from "next/dynamic";
 import { redirect } from "next/navigation";
+import { RevenueChart } from "@/components/admin/revenue-chart";
 import { StatsCard } from "@/components/admin/stats-card";
 import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
-import { Skeleton } from "@/components/ui/skeleton";
 import { canAccess, getAdminContext, PERMS } from "@/lib/permissions";
 import { prisma } from "@/lib/prisma";
 
-const RevenueChart = dynamic(
+type EconomyData = {
-	() =>
+	totalCredits: number;
-		import("@/components/admin/revenue-chart").then((m) => ({
+	totalPixels: number;
-			default: m.RevenueChart,
+	totalPoints: number;
-		})),
+	shopPurchases: number;
-	{ loading: () => <Skeleton className="h-[300px] w-full rounded-xl" /> },
+	shopCreditsSpent: number;
-);
+	shopPointsSpent: number;
+	marketplaceActive: number;
+	marketplaceSold: number;
+	weekTrades: number;
+	revenueData: { label: string; credits: number; points: number }[];
+};
 
-async function getEconomyData() {
+const EMPTY: EconomyData = {
+	totalCredits: 0,
+	totalPixels: 0,
+	totalPoints: 0,
+	shopPurchases: 0,
+	shopCreditsSpent: 0,
+	shopPointsSpent: 0,
+	marketplaceActive: 0,
+	marketplaceSold: 0,
+	weekTrades: 0,
+	revenueData: [],
+};
+
+async function safeCount(fn: () => Promise<number>): Promise<number> {
+	try {
+		return await fn();
+	} catch {
+		return 0;
+	}
+}
+
+async function getEconomyData(): Promise<EconomyData> {
 	const now = Math.floor(Date.now() / 1000);
 	const todayStart = now - (now % 86400);
 	const weekAgo = now - 7 * 86400;
+	const rangeStart = todayStart - 6 * 86400;
 
-	// Total currency in circulation — parallel instead of sequential
+	try {
 		const [creditsAgg, pixelsAgg, pointsAgg] = await Promise.all([
-		prisma.user.aggregate({ _sum: { credits: true } }),
+			prisma.user.aggregate({ _sum: { credits: true } }).catch(() => null),
-		prisma.user.aggregate({ _sum: { pixels: true } }),
+			prisma.user.aggregate({ _sum: { pixels: true } }).catch(() => null),
-		prisma.user.aggregate({ _sum: { points: true } }),
+			prisma.user.aggregate({ _sum: { points: true } }).catch(() => null),
 		]);
-	const totalCredits = creditsAgg._sum.credits ?? 0;
+		const totalCredits = creditsAgg?._sum.credits ?? 0;
-	const totalPixels = pixelsAgg._sum.pixels ?? 0;
+		const totalPixels = pixelsAgg?._sum.pixels ?? 0;
-	const totalPoints = pointsAgg._sum.points ?? 0;
+		const totalPoints = pointsAgg?._sum.points ?? 0;
 
-	// Shop revenue (7 days)
+		let shopPurchases = 0;
+		let shopCreditsSpent = 0;
+		let shopPointsSpent = 0;
+		try {
 			const shopRevenue = await prisma.logsShopPurchases.aggregate({
 				where: { timestamp: { gte: weekAgo } },
 				_sum: { costCredits: true, costPoints: true },
 				_count: true,
 			});
+			shopPurchases =
+				typeof shopRevenue._count === "number" ? shopRevenue._count : 0;
+			shopCreditsSpent = shopRevenue._sum?.costCredits ?? 0;
+			shopPointsSpent = shopRevenue._sum?.costPoints ?? 0;
+		} catch {
+			/* shop logs table/columns may be missing */
+		}
 
-	// Marketplace stats
+		const [marketplaceActive, marketplaceSold, weekTrades] = await Promise.all(
-	const marketplaceActive = await prisma.marketplaceItems.count({
+			[
-		where: { state: 1 },
+				safeCount(() =>
-	});
+					prisma.marketplaceItems.count({ where: { state: 1 } }),
-	const marketplaceSold = await prisma.marketplaceItems.count({
+				),
+				safeCount(() =>
+					prisma.marketplaceItems.count({
 						where: { state: 2, soldTimestamp: { gte: weekAgo } },
-	});
+					}),
+				),
+				safeCount(() =>
+					prisma.roomTradeLog.count({ where: { timestamp: { gte: weekAgo } } }),
+				),
+			],
+		);
 
-	// Revenue chart (7 days) — single GROUP BY query instead of 7 sequential queries
+		const revenueData: EconomyData["revenueData"] = [];
-	const rangeStart = todayStart - 6 * 86400;
+		for (let i = 6; i >= 0; i--) {
+			const dayStart = todayStart - i * 86400;
+			const date = new Date(dayStart * 1000);
+			revenueData.push({
+				label: date.toLocaleDateString("en", { weekday: "short" }),
+				credits: 0,
+				points: 0,
+			});
+		}
+
+		try {
 			const revRows = await prisma.$queryRaw<
-		{ day_bucket: bigint; credits: number; points: number }[]
+				{ day_bucket: bigint; credits: number | bigint; points: number | bigint }[]
 			>`
         SELECT FLOOR(timestamp / 86400) AS day_bucket,
                COALESCE(SUM(cost_credits), 0) AS credits,
@@ -63,37 +117,33 @@ async function getEconomyData() {
 					{ credits: Number(r.credits), points: Number(r.points) },
 				]),
 			);
-	const revenueData = [];
+			for (let i = 0; i < revenueData.length; i++) {
-	for (let i = 6; i >= 0; i--) {
+				const dayStart = todayStart - (6 - i) * 86400;
-		const dayStart = todayStart - i * 86400;
 				const bucket = Math.floor(dayStart / 86400);
-		const date = new Date(dayStart * 1000);
 				const entry = revMap.get(bucket);
-		revenueData.push({
+				if (entry) {
-			label: date.toLocaleDateString("en", { weekday: "short" }),
+					revenueData[i] = { ...revenueData[i], ...entry };
-			credits: entry?.credits ?? 0,
+				}
-			points: entry?.points ?? 0,
+			}
-		});
+		} catch {
+			/* keep zero revenue series */
 		}
-
-	// Trades (7 days)
-	const weekTrades = await prisma.roomTradeLog.count({
-		where: { timestamp: { gte: weekAgo } },
-	});
 
 		return {
 			totalCredits,
 			totalPixels,
 			totalPoints,
-		shopPurchases:
+			shopPurchases,
-			typeof shopRevenue._count === "number" ? shopRevenue._count : 0,
+			shopCreditsSpent,
-		shopCreditsSpent: shopRevenue._sum?.costCredits ?? 0,
+			shopPointsSpent,
-		shopPointsSpent: shopRevenue._sum?.costPoints ?? 0,
 			marketplaceActive,
 			marketplaceSold,
 			weekTrades,
 			revenueData,
 		};
+	} catch {
+		return EMPTY;
+	}
 }
 
 export default async function EconomyPage() {

src/app/admin/analytics/page.tsx

@@ -6,36 +6,60 @@ import {
 	TrendingUp,
 	Users,
 } from "lucide-react";
-import dynamic from "next/dynamic";
 import { redirect } from "next/navigation";
+import { DashboardChart } from "@/components/admin/dashboard-chart";
+import { PeakHoursHeatmap } from "@/components/admin/peak-hours-heatmap";
 import { StatsCard } from "@/components/admin/stats-card";
 import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
-import { Skeleton } from "@/components/ui/skeleton";
 import { canAccess, getAdminContext, PERMS } from "@/lib/permissions";
 import { prisma } from "@/lib/prisma";
 
-const DashboardChart = dynamic(
+type AnalyticsData = {
-	() =>
+	totalUsers: number;
-		import("@/components/admin/dashboard-chart").then((m) => ({
+	onlineUsers: number;
-			default: m.DashboardChart,
+	weekRegistrations: number;
-		})),
+	monthRegistrations: number;
-	{ loading: () => <Skeleton className="h-[300px] w-full rounded-xl" /> },
+	totalRooms: number;
-);
+	activeRooms: number;
+	weekChatMessages: number;
+	weekTrades: number;
+	weekBans: number;
+	registrationChart: { label: string; value: number }[];
+	peakHours: { grid: number[][]; max: number };
+};
 
-const PeakHoursHeatmap = dynamic(
+const EMPTY: AnalyticsData = {
-	() =>
+	totalUsers: 0,
-		import("@/components/admin/peak-hours-heatmap").then((m) => ({
+	onlineUsers: 0,
-			default: m.PeakHoursHeatmap,
+	weekRegistrations: 0,
-		})),
+	monthRegistrations: 0,
-	{ loading: () => <Skeleton className="h-[250px] w-full rounded-xl" /> },
+	totalRooms: 0,
-);
+	activeRooms: 0,
+	weekChatMessages: 0,
+	weekTrades: 0,
+	weekBans: 0,
+	registrationChart: [],
+	peakHours: {
+		grid: Array.from({ length: 7 }, () => Array(24).fill(0)),
+		max: 0,
+	},
+};
 
-async function getAnalyticsData() {
+async function safeCount(fn: () => Promise<number>): Promise<number> {
+	try {
+		return await fn();
+	} catch {
+		return 0;
+	}
+}
+
+async function getAnalyticsData(): Promise<AnalyticsData> {
 	const now = Math.floor(Date.now() / 1000);
 	const todayStart = now - (now % 86400);
 	const weekAgo = now - 7 * 86400;
 	const monthAgo = now - 30 * 86400;
 
+	try {
 		const [
 			totalUsers,
 			onlineUsers,
@@ -47,20 +71,35 @@ async function getAnalyticsData() {
 			weekTrades,
 			weekBans,
 		] = await Promise.all([
-		prisma.user.count(),
+			safeCount(() => prisma.user.count()),
-		prisma.user.count({ where: { online: "1" } }),
+			safeCount(() => prisma.user.count({ where: { online: "1" } })),
+			safeCount(() =>
 				prisma.user.count({ where: { accountCreated: { gte: weekAgo } } }),
+			),
+			safeCount(() =>
 				prisma.user.count({ where: { accountCreated: { gte: monthAgo } } }),
-		prisma.rooms.count(),
+			),
-		prisma.rooms.count({ where: { users: { gt: 0 } } }),
+			safeCount(() => prisma.rooms.count()),
-		prisma.$queryRaw<
+			safeCount(() => prisma.rooms.count({ where: { users: { gt: 0 } } })),
-			{ count: bigint }[]
+			(async () => {
-		>`SELECT COUNT(*) AS count FROM chatlogs_room WHERE timestamp >= ${weekAgo}`,
+				try {
+					const rows = await prisma.$queryRaw<{ count: bigint }[]>`
+            SELECT COUNT(*) AS count FROM chatlogs_room WHERE timestamp >= ${weekAgo}`;
+					return Number(rows[0]?.count ?? 0);
+				} catch {
+					return 0;
+				}
+			})(),
+			safeCount(() =>
 				prisma.roomTradeLog.count({ where: { timestamp: { gte: weekAgo } } }),
+			),
+			safeCount(() =>
 				prisma.ban.count({ where: { timestamp: { gte: weekAgo } } }),
+			),
 		]);
 
-	// Registration chart (30 days) — single GROUP BY query instead of 30 sequential queries
+		let registrationChart: { label: string; value: number }[] = [];
+		try {
 			const regRows = await prisma.$queryRaw<
 				{ day_bucket: bigint; count: bigint }[]
 			>`
@@ -72,18 +111,25 @@ async function getAnalyticsData() {
 			const regCountMap = new Map(
 				regRows.map((r) => [Number(r.day_bucket), Number(r.count)]),
 			);
-	const registrationChart = [];
 			for (let i = 29; i >= 0; i--) {
 				const dayStart = todayStart - i * 86400;
 				const bucket = Math.floor(dayStart / 86400);
 				const date = new Date(dayStart * 1000);
 				registrationChart.push({
-			label: date.toLocaleDateString("en", { month: "short", day: "numeric" }),
+					label: date.toLocaleDateString("en", {
+						month: "short",
+						day: "numeric",
+					}),
 					value: regCountMap.get(bucket) ?? 0,
 				});
 			}
+		} catch {
+			registrationChart = [];
+		}
 
-	// Peak hours — single GROUP BY query instead of fetching all user rows
+		const grid: number[][] = Array.from({ length: 7 }, () => Array(24).fill(0));
+		let max = 0;
+		try {
 			const peakRows = await prisma.$queryRaw<
 				{ d: number; h: number; c: bigint }[]
 			>`
@@ -94,13 +140,17 @@ async function getAnalyticsData() {
         WHERE last_online >= ${weekAgo}
         GROUP BY d, h
       `;
-	const grid: number[][] = Array.from({ length: 7 }, () => Array(24).fill(0));
-	let max = 0;
 			for (const r of peakRows) {
+				const day = Number(r.d);
+				const hour = Number(r.h);
+				if (day < 0 || day > 6 || hour < 0 || hour > 23) continue;
 				const count = Number(r.c);
-		grid[r.d][r.h] = count;
+				grid[day][hour] = count;
 				if (count > max) max = count;
 			}
+		} catch {
+			/* keep empty grid */
+		}
 
 		return {
 			totalUsers,
@@ -109,14 +159,15 @@ async function getAnalyticsData() {
 			monthRegistrations,
 			totalRooms,
 			activeRooms,
-		weekChatMessages: Array.isArray(weekChatMessages)
+			weekChatMessages,
-			? Number(weekChatMessages[0]?.count ?? 0)
-			: 0,
 			weekTrades,
 			weekBans,
 			registrationChart,
 			peakHours: { grid, max },
 		};
+	} catch {
+		return EMPTY;
+	}
 }
 
 export default async function AnalyticsPage() {