@studious-lms/server 1.27.0 → 1.28.0

package/src/services/adminTelemetry.ts

@@ -0,0 +1,194 @@
+import { Prisma } from '@prisma/client';
+import { prisma } from '../lib/prisma.js';
+
+export type DailyPoint = {
+  date: string;
+  signups: number;
+  logins: number;
+  assignments: number;
+  submissions: number;
+  messages: number;
+};
+
+type DayRow = { day: Date; total: bigint };
+
+function dayKey(date: Date): string {
+  return date.toISOString().slice(0, 10);
+}
+
+async function dailyCounts(
+  table: Prisma.Sql,
+  column: Prisma.Sql,
+  since: Date,
+  extra: Prisma.Sql = Prisma.empty,
+): Promise<Map<string, number>> {
+  const rows = await prisma.$queryRaw<DayRow[]>`
+    SELECT date_trunc('day', ${column}) AS day, count(*) AS total
+    FROM ${table}
+    WHERE ${column} >= ${since} ${extra}
+    GROUP BY 1
+  `;
+  return new Map(rows.map((row) => [dayKey(row.day), Number(row.total)]));
+}
+
+async function dailyDistinctLogins(since: Date): Promise<Map<string, number>> {
+  const rows = await prisma.$queryRaw<DayRow[]>`
+    SELECT date_trunc('day', "createdAt") AS day,
+           count(DISTINCT "userId") AS total
+    FROM "Session"
+    WHERE "createdAt" >= ${since} AND "type" = 'AUTH' AND "userId" IS NOT NULL
+    GROUP BY 1
+  `;
+  return new Map(rows.map((row) => [dayKey(row.day), Number(row.total)]));
+}
+
+/**
+ * Per-day platform activity for the last `days` days, zero-filled so the admin
+ * chart always has one point per day even when nothing happened.
+ */
+export async function getActivitySeriesForAdmin(input: {
+  days: number;
+}): Promise<{ points: DailyPoint[] }> {
+  const days = Math.min(Math.max(input.days, 1), 90);
+  const since = new Date(Date.now() - (days - 1) * 24 * 60 * 60 * 1000);
+  since.setUTCHours(0, 0, 0, 0);
+
+  const [signups, logins, assignments, submissions, messages] =
+    await Promise.all([
+      dailyCounts(Prisma.sql`"UserProfile"`, Prisma.sql`"createdAt"`, since),
+      dailyDistinctLogins(since),
+      dailyCounts(Prisma.sql`"Assignment"`, Prisma.sql`"createdAt"`, since),
+      dailyCounts(Prisma.sql`"Submission"`, Prisma.sql`"createdAt"`, since),
+      dailyCounts(Prisma.sql`"Message"`, Prisma.sql`"createdAt"`, since),
+    ]);
+
+  const points: DailyPoint[] = [];
+  for (let offset = 0; offset < days; offset += 1) {
+    const date = new Date(since.getTime() + offset * 24 * 60 * 60 * 1000);
+    const key = dayKey(date);
+    points.push({
+      date: key,
+      signups: signups.get(key) ?? 0,
+      logins: logins.get(key) ?? 0,
+      assignments: assignments.get(key) ?? 0,
+      submissions: submissions.get(key) ?? 0,
+      messages: messages.get(key) ?? 0,
+    });
+  }
+
+  return { points };
+}
+
+/** Content inventory plus AI/job health, i.e. "what is actually on the platform". */
+export async function getContentTelemetryForAdmin() {
+  const dayAgo = new Date(Date.now() - 24 * 60 * 60 * 1000);
+  const weekAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
+
+  const [
+    assignments,
+    assignmentsLast7d,
+    submissions,
+    submissionsLast7d,
+    gradedSubmissions,
+    announcements,
+    announcementsLast7d,
+    discussions,
+    messages,
+    messagesLast7d,
+    worksheets,
+    events,
+    modules,
+    files,
+    fileSize,
+    aiCalls7d,
+    aiFailures7d,
+    aiTokens7d,
+    aiByModel7d,
+    runJobsByType7d,
+    failedJobsLast24h,
+  ] = await Promise.all([
+    prisma.assignment.count(),
+    prisma.assignment.count({ where: { createdAt: { gte: weekAgo } } }),
+    prisma.submission.count(),
+    prisma.submission.count({ where: { createdAt: { gte: weekAgo } } }),
+    prisma.submission.count({ where: { gradeReceived: { not: null } } }),
+    prisma.announcement.count(),
+    prisma.announcement.count({ where: { createdAt: { gte: weekAgo } } }),
+    prisma.discussion.count(),
+    prisma.message.count(),
+    prisma.message.count({ where: { createdAt: { gte: weekAgo } } }),
+    prisma.worksheet.count(),
+    prisma.event.count(),
+    prisma.module.count(),
+    prisma.file.count(),
+    prisma.file.aggregate({ _sum: { size: true } }),
+    prisma.aiUsageLog.count({ where: { createdAt: { gte: weekAgo } } }),
+    prisma.aiUsageLog.count({
+      where: { createdAt: { gte: weekAgo }, success: false },
+    }),
+    prisma.aiUsageLog.aggregate({
+      where: { createdAt: { gte: weekAgo } },
+      _sum: { totalTokens: true },
+    }),
+    prisma.aiUsageLog.groupBy({
+      by: ['model'],
+      where: { createdAt: { gte: weekAgo } },
+      _count: { _all: true },
+      _sum: { totalTokens: true },
+    }),
+    prisma.runJob.groupBy({
+      by: ['type', 'status'],
+      where: { createdAt: { gte: weekAgo } },
+      _count: { _all: true },
+    }),
+    prisma.runJob.count({
+      where: { status: 'FAILED', createdAt: { gte: dayAgo } },
+    }),
+  ]);
+
+  const jobsByType = new Map<string, { total: number; failed: number }>();
+  for (const row of runJobsByType7d) {
+    const entry = jobsByType.get(row.type) ?? { total: 0, failed: 0 };
+    entry.total += row._count._all;
+    if (row.status === 'FAILED') entry.failed += row._count._all;
+    jobsByType.set(row.type, entry);
+  }
+
+  return {
+    content: {
+      assignments,
+      assignmentsLast7d,
+      submissions,
+      submissionsLast7d,
+      gradedSubmissions,
+      announcements,
+      announcementsLast7d,
+      discussions,
+      messages,
+      messagesLast7d,
+      worksheets,
+      events,
+      modules,
+      files,
+      storageBytes: Number(fileSize._sum.size ?? 0),
+    },
+    ai: {
+      calls7d: aiCalls7d,
+      failures7d: aiFailures7d,
+      tokens7d: aiTokens7d._sum.totalTokens ?? 0,
+      byModel: aiByModel7d
+        .map((row) => ({
+          model: row.model,
+          calls: row._count._all,
+          tokens: row._sum.totalTokens ?? 0,
+        }))
+        .sort((a, b) => b.calls - a.calls),
+    },
+    jobs: {
+      failedLast24h: failedJobsLast24h,
+      byType: [...jobsByType.entries()]
+        .map(([type, counts]) => ({ type, ...counts }))
+        .sort((a, b) => b.total - a.total),
+    },
+  };
+}

package/src/services/adminUser.ts

@@ -1,26 +1,70 @@
 import type { Prisma } from '@prisma/client';
 import { TRPCError } from '@trpc/server';
 import { prisma } from '../lib/prisma.js';
+import { classifyUser, suspectedUserWhere } from './adminSpam.js';
+import { listClassesForUserForAdmin } from './adminClass.js';
+
+export type AdminUserSpamFilter = 'all' | 'suspected' | 'clean';
+export type AdminUserActivityFilter = 'all' | 'active' | 'inactive';
+export type AdminUserSort = 'username' | 'recent' | 'activity';
 
 export async function searchUsersForAdmin(input: {
   page: number;
   pageSize: number;
   query?: string;
+  emailDomain?: string;
+  schoolId?: string;
+  verified?: boolean;
+  spam?: AdminUserSpamFilter;
+  activity?: AdminUserActivityFilter;
+  sort?: AdminUserSort;
 }) {
   const skip = input.page * input.pageSize;
-  const where: Prisma.UserWhereInput = {};
+  const filters: Prisma.UserWhereInput[] = [];
+
   const q = input.query?.trim();
   if (q) {
-    where.OR = [
-      { username: { contains: q, mode: 'insensitive' } },
-      { email: { contains: q, mode: 'insensitive' } },
-    ];
+    filters.push({
+      OR: [
+        { username: { contains: q, mode: 'insensitive' } },
+        { email: { contains: q, mode: 'insensitive' } },
+      ],
+    });
+  }
+
+  const domain = input.emailDomain?.trim().replace(/^@/, '');
+  if (domain) {
+    filters.push({ email: { endsWith: `@${domain}`, mode: 'insensitive' } });
+  }
+
+  if (input.schoolId) filters.push({ schoolId: input.schoolId });
+  if (input.verified !== undefined) filters.push({ verified: input.verified });
+
+  if (input.spam === 'suspected') filters.push(suspectedUserWhere());
+  if (input.spam === 'clean') filters.push({ NOT: suspectedUserWhere() });
+
+  // "Active" means the account is attached to at least one class — the cheapest
+  // proxy for a real account that is actually using the platform.
+  if (input.activity === 'active') {
+    filters.push({ OR: [{ teacherIn: { some: {} } }, { studentIn: { some: {} } }] });
+  }
+  if (input.activity === 'inactive') {
+    filters.push({ teacherIn: { none: {} }, studentIn: { none: {} } });
   }
 
+  const where: Prisma.UserWhereInput = filters.length ? { AND: filters } : {};
+
+  const orderBy: Prisma.UserOrderByWithRelationInput[] =
+    input.sort === 'recent'
+      ? [{ profile: { createdAt: 'desc' } }, { username: 'asc' }]
+      : input.sort === 'activity'
+        ? [{ submissions: { _count: 'desc' } }, { username: 'asc' }]
+        : [{ username: 'asc' }];
+
   const [items, total] = await Promise.all([
     prisma.user.findMany({
       where,
-      orderBy: { username: 'asc' },
+      orderBy,
       skip,
       take: input.pageSize,
       select: {
@@ -28,9 +72,15 @@ export async function searchUsersForAdmin(input: {
         username: true,
         email: true,
         verified: true,
+        profile: { select: { createdAt: true } },
         school: { select: { id: true, name: true } },
         _count: {
-          select: { teacherIn: true, studentIn: true, sessions: true },
+          select: {
+            teacherIn: true,
+            studentIn: true,
+            submissions: true,
+            sessions: { where: { type: 'AUTH' } },
+          },
         },
       },
     }),
@@ -38,7 +88,7 @@ export async function searchUsersForAdmin(input: {
   ]);
 
   return {
-    items,
+    items: items.map((user) => ({ ...user, signals: classifyUser(user) })),
     total,
     page: input.page,
     pageSize: input.pageSize,
@@ -92,5 +142,7 @@ export async function getUserForAdmin(id: string) {
   if (!user) {
     throw new TRPCError({ code: 'NOT_FOUND', message: 'User not found' });
   }
-  return user;
+
+  const classes = await listClassesForUserForAdmin(id);
+  return { ...user, classes, signals: classifyUser(user) };
 }

package/src/services/auth.ts

@@ -182,7 +182,10 @@ export async function resendVerificationEmail(email: string) {
     });
   }
 
-  await deleteSessionsByUserId(user.id);
+  // Do NOT delete the user's sessions here — resending a verification email
+  // must never log the account out of its active devices. A previously issued
+  // verification token simply expires on its own; issuing a fresh one is
+  // enough.
 
   const verificationToken = await createSession({
     id: uuidv4(),
@@ -298,6 +301,9 @@ export async function resetPassword(token: string, password: string) {
   }
 
   await updateUserPassword(session.userId, await hash(password, 10));
-  await deleteSessionById(token);
+  // Revoke every session (AUTH + any other reset/verification tokens), not
+  // just the consumed reset token, so a stolen bearer token can't outlive a
+  // password reset.
+  await deleteSessionsByUserId(session.userId);
   return { success: true };
 }

package/src/services/fees.ts

@@ -428,8 +428,12 @@ export async function getReceiptPdf(userId: string, paymentId: string) {
       },
       {
         label: "Paid at",
+        // Format in UTC rather than a hardcoded country timezone — Studious is
+        // used internationally, and this matches the UTC basis already used
+        // for invoice month labels. A per-school timezone setting is the
+        // proper long-term home for this (see docs/audits bug audit §2).
         value: new Intl.DateTimeFormat("en-CA", {
-          timeZone: "Asia/Kathmandu",
+          timeZone: "UTC",
           year: "numeric",
           month: "2-digit",
           day: "2-digit",

package/src/services/module.ts

@@ -182,6 +182,7 @@ const CONTENT_TYPES: ModuleItemType[] = [
   ModuleItemType.FILE,
   ModuleItemType.ANNOUNCEMENT,
   ModuleItemType.DISCUSSION,
+  ModuleItemType.VISUALIZATION,
 ];
 
 const SUBMITTABLE_TYPES: ModuleItemType[] = [
@@ -235,7 +236,9 @@ async function validateItemInput(
             ? await prisma.announcement.findFirst({ where: { id: itemId, classId } })
             : itemType === ModuleItemType.DISCUSSION
               ? await prisma.discussion.findFirst({ where: { id: itemId, classId } })
-              : await prisma.file.findUnique({ where: { id: itemId } });
+              : itemType === ModuleItemType.VISUALIZATION
+                ? await prisma.visualization.findFirst({ where: { id: itemId, classId } })
+                : await prisma.file.findUnique({ where: { id: itemId } });
     if (!exists) {
       throw new TRPCError({
         code: "NOT_FOUND",
@@ -437,11 +440,35 @@ function isModuleComplete(
  * completion/accessibility and per-module progress percentages.
  */
 export async function getStudentModulesState(classId: string, studentId: string) {
-  const [modules, progress] = await Promise.all([
+  const [allModules, progress] = await Promise.all([
     findModulesByClassId(classId, true),
     findStudentProgressForClass(classId, studentId),
   ]);
 
+  // Hide visualisations the teacher hasn't published yet.
+  const visualizationIds = allModules
+    .flatMap((m) => m.items)
+    .filter((i) => i.itemType === ModuleItemType.VISUALIZATION && i.itemId)
+    .map((i) => i.itemId as string);
+  const publishedVisualizationIds = new Set(
+    visualizationIds.length
+      ? (
+          await prisma.visualization.findMany({
+            where: { id: { in: visualizationIds }, classId, published: true },
+            select: { id: true },
+          })
+        ).map((v) => v.id)
+      : []
+  );
+  const modules = allModules.map((m) => ({
+    ...m,
+    items: m.items.filter(
+      (i) =>
+        i.itemType !== ModuleItemType.VISUALIZATION ||
+        (!!i.itemId && publishedVisualizationIds.has(i.itemId))
+    ),
+  }));
+
   const completedItemIds = new Set(
     progress
       .filter((p) => p.status === ModuleItemProgressStatus.COMPLETE)

package/src/services/visualization.ts

@@ -0,0 +1,147 @@
+import { TRPCError } from "@trpc/server";
+import { prisma } from "../lib/prisma.js";
+import { isTeacherInClass } from "../models/class.js";
+import {
+  generateVisualization,
+  MAX_VISUALIZATION_HTML_LENGTH,
+  reviseVisualization,
+} from "../pipelines/generateVisualization.js";
+
+const summarySelect = {
+  id: true,
+  classId: true,
+  title: true,
+  prompt: true,
+  published: true,
+  createdAt: true,
+  updatedAt: true,
+} as const;
+
+const detailSelect = { ...summarySelect, html: true } as const;
+
+async function getClassContext(classId: string) {
+  return prisma.class.findUnique({
+    where: { id: classId },
+    select: { name: true, subject: true, schoolId: true },
+  });
+}
+
+async function findTeacherVisualization(classId: string, id: string) {
+  const viz = await prisma.visualization.findFirst({
+    where: { id, classId },
+    select: detailSelect,
+  });
+  if (!viz) {
+    throw new TRPCError({ code: "NOT_FOUND", message: "Visualisation not found" });
+  }
+  return viz;
+}
+
+function aiError(error: unknown): never {
+  throw new TRPCError({
+    code: "INTERNAL_SERVER_ERROR",
+    message: "Newton couldn't build that visualisation. Try rephrasing it.",
+    cause: error,
+  });
+}
+
+/** Teachers see every visualisation in the class; students only published ones. */
+export async function listVisualizations(userId: string, classId: string) {
+  const isTeacher = !!(await isTeacherInClass(classId, userId));
+  return prisma.visualization.findMany({
+    where: { classId, ...(isTeacher ? {} : { published: true }) },
+    select: summarySelect,
+    orderBy: { updatedAt: "desc" },
+  });
+}
+
+export async function getVisualization(userId: string, classId: string, id: string) {
+  const isTeacher = !!(await isTeacherInClass(classId, userId));
+  const viz = await prisma.visualization.findFirst({
+    where: { id, classId, ...(isTeacher ? {} : { published: true }) },
+    select: detailSelect,
+  });
+  if (!viz) {
+    throw new TRPCError({ code: "NOT_FOUND", message: "Visualisation not found" });
+  }
+  return viz;
+}
+
+export async function createVisualization(
+  userId: string,
+  input: { classId: string; prompt: string; title?: string },
+) {
+  const cls = await getClassContext(input.classId);
+  const generated = await generateVisualization(input.prompt, {
+    className: cls?.name,
+    subject: cls?.subject,
+    attribution: { userId, classId: input.classId, schoolId: cls?.schoolId },
+  }).catch(aiError);
+
+  return prisma.visualization.create({
+    data: {
+      classId: input.classId,
+      createdById: userId,
+      title: input.title?.trim() || generated.title,
+      prompt: input.prompt,
+      html: generated.html,
+    },
+    select: detailSelect,
+  });
+}
+
+export async function reviseVisualizationRecord(
+  userId: string,
+  input: { classId: string; id: string; instruction: string },
+) {
+  const current = await findTeacherVisualization(input.classId, input.id);
+  const cls = await getClassContext(input.classId);
+  const revised = await reviseVisualization(current, input.instruction, {
+    className: cls?.name,
+    subject: cls?.subject,
+    attribution: { userId, classId: input.classId, schoolId: cls?.schoolId },
+  }).catch(aiError);
+
+  return prisma.visualization.update({
+    where: { id: current.id },
+    data: {
+      html: revised.html,
+      prompt: [current.prompt, input.instruction].filter(Boolean).join("\n\n"),
+    },
+    select: detailSelect,
+  });
+}
+
+export async function updateVisualization(input: {
+  classId: string;
+  id: string;
+  title?: string;
+  html?: string;
+  published?: boolean;
+}) {
+  const current = await findTeacherVisualization(input.classId, input.id);
+  if (input.html !== undefined && input.html.length > MAX_VISUALIZATION_HTML_LENGTH) {
+    throw new TRPCError({ code: "BAD_REQUEST", message: "Visualisation is too large" });
+  }
+  return prisma.visualization.update({
+    where: { id: current.id },
+    data: {
+      ...(input.title !== undefined ? { title: input.title } : {}),
+      ...(input.html !== undefined ? { html: input.html } : {}),
+      ...(input.published !== undefined ? { published: input.published } : {}),
+    },
+    select: detailSelect,
+  });
+}
+
+/** Deletes the visualisation and any module items that pointed at it. */
+export async function deleteVisualization(input: { classId: string; id: string }) {
+  const current = await findTeacherVisualization(input.classId, input.id);
+  await prisma.$transaction([
+    prisma.courseModuleItem.deleteMany({
+      where: { itemType: "VISUALIZATION", itemId: current.id },
+    }),
+    prisma.visualization.delete({ where: { id: current.id } }),
+  ]);
+  return { id: current.id };
+}

package/src/utils/sentryTrpc.ts

@@ -0,0 +1,25 @@
+import type { TRPCError } from '@trpc/server';
+
+/**
+ * Error codes that mean "the caller did something wrong" — noise in Sentry.
+ * Everything else (server faults, unhandled Prisma/AI failures) is reported.
+ */
+const EXPECTED_CODES = new Set([
+  'BAD_REQUEST',
+  'PARSE_ERROR',
+  'UNAUTHORIZED',
+  'FORBIDDEN',
+  'NOT_FOUND',
+  'CONFLICT',
+  'PRECONDITION_FAILED',
+  'PAYLOAD_TOO_LARGE',
+  'UNPROCESSABLE_CONTENT',
+  'TOO_MANY_REQUESTS',
+  'CLIENT_CLOSED_REQUEST',
+  'METHOD_NOT_SUPPORTED',
+  'UNSUPPORTED_MEDIA_TYPE',
+]);
+
+export function isReportableTrpcError(error: Pick<TRPCError, 'code'>): boolean {
+  return !EXPECTED_CODES.has(error.code);
+}

package/tests/unit/lib/fileUploadSession.test.ts

@@ -0,0 +1,67 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { TRPCError } from '@trpc/server';
+
+const prismaMocks = vi.hoisted(() => ({
+  file: { findFirst: vi.fn() },
+}));
+
+vi.mock('../../../src/lib/prisma.js', () => ({ prisma: prismaMocks }));
+// GCS client construction touches credentials at import — stub it out.
+vi.mock('../../../src/lib/googleCloudStorage.js', () => ({
+  getSignedUrl: vi.fn(),
+  objectExists: vi.fn(),
+}));
+// env.ts validates process.env at import; the function under test never reads
+// env, so a bare stub keeps the import graph from exiting the process.
+vi.mock('../../../src/lib/config/env.js', () => ({ env: {} }));
+
+import { validateDirectUploadSession } from '../../../src/lib/fileUpload.js';
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+describe('validateDirectUploadSession', () => {
+  test('rejects when no upload session id is supplied', async () => {
+    await expect(
+      validateDirectUploadSession({ filePath: 'a/b.png', uploadSessionId: undefined }),
+    ).rejects.toMatchObject({ code: 'FORBIDDEN' } satisfies Partial<TRPCError>);
+    expect(prismaMocks.file.findFirst).not.toHaveBeenCalled();
+  });
+
+  test('rejects when no pending record matches the path + session', async () => {
+    prismaMocks.file.findFirst.mockResolvedValue(null);
+    await expect(
+      validateDirectUploadSession({ filePath: 'a/b.png', uploadSessionId: 'sess-1' }),
+    ).rejects.toMatchObject({ code: 'FORBIDDEN' } satisfies Partial<TRPCError>);
+
+    // Capability is keyed on path + session + unexpired + not orphaned.
+    const where = prismaMocks.file.findFirst.mock.calls[0][0].where;
+    expect(where).toMatchObject({
+      path: 'a/b.png',
+      uploadSessionId: 'sess-1',
+      isOrphaned: false,
+    });
+    expect(where.uploadExpiresAt.gt).toBeInstanceOf(Date);
+  });
+
+  test('rejects a record that is no longer accepting data', async () => {
+    prismaMocks.file.findFirst.mockResolvedValue({
+      id: 'f1',
+      uploadStatus: 'COMPLETED',
+    });
+    await expect(
+      validateDirectUploadSession({ filePath: 'a/b.png', uploadSessionId: 'sess-1' }),
+    ).rejects.toMatchObject({ code: 'BAD_REQUEST' } satisfies Partial<TRPCError>);
+  });
+
+  test('accepts a pending record for the exact path + session', async () => {
+    prismaMocks.file.findFirst.mockResolvedValue({
+      id: 'f1',
+      uploadStatus: 'PENDING',
+    });
+    await expect(
+      validateDirectUploadSession({ filePath: 'a/b.png', uploadSessionId: 'sess-1' }),
+    ).resolves.toMatchObject({ id: 'f1' });
+  });
+});