@studious-lms/server 1.26.0 → 1.28.0

package/src/routers/message.ts

@@ -9,9 +9,12 @@ import {
   confirmMessageUpload,
   markAsRead,
   markMentionsAsRead,
-  markSuggestionCreated,
   getUnreadCount,
+  regenerateAIResponse,
+  setAIMessageFeedback,
 } from "../services/message.js";
+import { resolveAiProposal } from "../services/aiProposals.js";
+import { cancelAiGeneration } from "../services/aiGeneration.js";
 
 export const messageRouter = createTRPCRouter({
   list: protectedProcedure
@@ -101,6 +104,12 @@ export const messageRouter = createTRPCRouter({
     .input(z.object({ messageId: z.string() }))
     .mutation(({ ctx, input }) => deleteMessage(ctx.user!.id, input.messageId)),
 
+  cancelAiGeneration: protectedProcedure
+    .input(z.object({ messageId: z.string() }))
+    .mutation(({ ctx, input }) =>
+      cancelAiGeneration(ctx.user!.id, input.messageId)
+    ),
+
   markAsRead: protectedProcedure
     .input(z.object({ conversationId: z.string() }))
     .mutation(({ ctx, input }) =>
@@ -113,16 +122,16 @@ export const messageRouter = createTRPCRouter({
       markMentionsAsRead(ctx.user!.id, input.conversationId)
     ),
 
-  markSuggestionCreated: protectedProcedure
+  resolveAiProposal: protectedProcedure
     .input(
       z.object({
         messageId: z.string(),
-        type: z.enum(["assignment", "worksheet", "section"]),
-        index: z.number().int().min(0),
+        proposalId: z.string(),
+        action: z.enum(["approve", "dismiss"]),
       })
     )
     .mutation(({ ctx, input }) =>
-      markSuggestionCreated(ctx.user!.id, input)
+      resolveAiProposal(ctx.user!.id, input)
     ),
 
   getUnreadCount: protectedProcedure
@@ -130,4 +139,24 @@ export const messageRouter = createTRPCRouter({
     .query(({ ctx, input }) =>
       getUnreadCount(ctx.user!.id, input.conversationId)
     ),
+
+  regenerateAIResponse: protectedProcedure
+    .input(z.object({ messageId: z.string() }))
+    .mutation(({ ctx, input }) =>
+      regenerateAIResponse(ctx.user!.id, input.messageId)
+    ),
+
+  setAIFeedback: protectedProcedure
+    .input(
+      z.object({
+        messageId: z.string(),
+        feedback: z.enum(["UP", "DOWN"]).nullable(),
+      })
+    )
+    .mutation(({ ctx, input }) =>
+      setAIMessageFeedback(ctx.user!.id, {
+        messageId: input.messageId,
+        feedback: input.feedback,
+      })
+    ),
 });

package/src/routers/parent.ts

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { createTRPCRouter, protectedProcedure } from "../trpc.js";
 import {
+  addParentToStudent,
   getChildAttendance,
   getChildGrades,
   linkParentToStudent,
@@ -20,6 +21,16 @@ export const parentRouter = createTRPCRouter({
     )
     .mutation(({ ctx, input }) => linkParentToStudent(ctx.user!.id, input)),
 
+  addToStudent: protectedProcedure
+    .input(
+      z.object({
+        schoolId: z.string(),
+        studentUserId: z.string(),
+        parentIdentifier: z.string().min(1),
+      })
+    )
+    .mutation(({ ctx, input }) => addParentToStudent(ctx.user!.id, input)),
+
   unlinkStudent: protectedProcedure
     .input(
       z.object({

package/src/routers/studentProgress.ts

@@ -7,6 +7,7 @@ import {
 import {
   chatAboutStudentProgress,
   dismissStudentRecommendation,
+  generateFollowUpAssignment,
   getClassProgressRecommendations,
   getStudentProgressFocus,
   getStudentProgressForecast,
@@ -66,6 +67,20 @@ export const studentProgressRouter = createTRPCRouter({
       dismissStudentRecommendation(ctx.user!.id, input),
     ),
 
+  generateFollowUpAssignment: protectedTeacherProcedure
+    .input(
+      z.object({
+        classId: z.string(),
+        studentId: z.string(),
+        submissionId: z.string(),
+        prompt: z.string().min(1).max(2000),
+        dueDate: z.string().datetime().optional(),
+      }),
+    )
+    .mutation(({ ctx, input }) =>
+      generateFollowUpAssignment(ctx.user!.id, input),
+    ),
+
   chat: protectedClassMemberProcedure
     .input(
       progressInputSchema.extend({

package/src/routers/visualization.ts

@@ -0,0 +1,60 @@
+import { z } from "zod";
+import {
+  createTRPCRouter,
+  protectedClassMemberProcedure,
+  protectedTeacherProcedure,
+} from "../trpc.js";
+import {
+  createVisualization,
+  deleteVisualization,
+  getVisualization,
+  listVisualizations,
+  reviseVisualizationRecord,
+  updateVisualization,
+} from "../services/visualization.js";
+
+export const visualizationRouter = createTRPCRouter({
+  list: protectedClassMemberProcedure
+    .input(z.object({ classId: z.string() }))
+    .query(({ ctx, input }) => listVisualizations(ctx.user!.id, input.classId)),
+
+  get: protectedClassMemberProcedure
+    .input(z.object({ classId: z.string(), id: z.string() }))
+    .query(({ ctx, input }) => getVisualization(ctx.user!.id, input.classId, input.id)),
+
+  generate: protectedTeacherProcedure
+    .input(
+      z.object({
+        classId: z.string(),
+        prompt: z.string().trim().min(3).max(4000),
+        title: z.string().trim().max(120).optional(),
+      }),
+    )
+    .mutation(({ ctx, input }) => createVisualization(ctx.user!.id, input)),
+
+  revise: protectedTeacherProcedure
+    .input(
+      z.object({
+        classId: z.string(),
+        id: z.string(),
+        instruction: z.string().trim().min(3).max(4000),
+      }),
+    )
+    .mutation(({ ctx, input }) => reviseVisualizationRecord(ctx.user!.id, input)),
+
+  update: protectedTeacherProcedure
+    .input(
+      z.object({
+        classId: z.string(),
+        id: z.string(),
+        title: z.string().trim().min(1).max(120).optional(),
+        html: z.string().min(1).optional(),
+        published: z.boolean().optional(),
+      }),
+    )
+    .mutation(({ input }) => updateVisualization(input)),
+
+  delete: protectedTeacherProcedure
+    .input(z.object({ classId: z.string(), id: z.string() }))
+    .mutation(({ input }) => deleteVisualization(input)),
+});

package/src/routes/aiStream.ts

@@ -453,6 +453,33 @@ aiStreamRouter.post('/modify/stream', async (req: Request, res: Response) => {
     Connection: 'keep-alive',
   });
 
+  // Narration is mirrored to other open editors as batched `modifier-chunk`
+  // events so their overlay streams live without a Pusher trigger per token.
+  const CHUNK_FLUSH_INTERVAL_MS = 250;
+  const CHUNK_FLUSH_MAX_CHARS = 500;
+  let chunkBuffer = '';
+  let lastChunkFlush = 0;
+  const flushChunks = async (force = false) => {
+    if (!chunkBuffer) return;
+    const now = Date.now();
+    if (
+      !force &&
+      now - lastChunkFlush < CHUNK_FLUSH_INTERVAL_MS &&
+      chunkBuffer.length < CHUNK_FLUSH_MAX_CHARS
+    ) {
+      return;
+    }
+    const payload = chunkBuffer;
+    chunkBuffer = '';
+    lastChunkFlush = now;
+    await pusher.trigger(channel, 'modifier-chunk', {
+      resourceId,
+      chunk: payload,
+    }).catch((err: unknown) => {
+      logger.warn('Failed to broadcast modifier-chunk', { err, resourceId });
+    });
+  };
+
   // Called after a tool persists a single field — apply it live everywhere.
   const onFieldUpdate = async (update: ModifierFieldUpdate) => {
     await pusher.trigger(channel, 'modifier-field-updated', {
@@ -466,6 +493,8 @@ aiStreamRouter.post('/modify/stream', async (req: Request, res: Response) => {
     });
     // Human-readable progress for the requesting client's bar.
     res.write(`Updated ${update.label}.\n`);
+    chunkBuffer += `Updated ${update.label}.\n`;
+    await flushChunks();
   };
 
   try {
@@ -490,7 +519,10 @@ aiStreamRouter.post('/modify/stream', async (req: Request, res: Response) => {
     // call onFieldUpdate); any narration text is forwarded to the SSE client.
     for await (const chunk of result.textStream) {
       res.write(chunk);
+      chunkBuffer += chunk;
+      await flushChunks();
     }
+    await flushChunks(true);
 
     // Clean up Redis flag and broadcast completion
     if (redis) {

package/src/seedDatabase.ts

@@ -1653,14 +1653,119 @@ export const seedDatabase = async () => {
             createdAt: hoursFromNow(-3, now),
         },
     });
+    // AI reply with creation proposals in all three states (pending card,
+    // approved row, dismissed row) so the approval flow is demo-able.
+    const labIntroText =
+        "Here's what I put together for the organelle functions unit. I drafted a 10-question quiz worksheet, and I'm proposing a graded quiz assignment plus a new section to keep the unit organized:";
+    const labProposals = [
+        {
+            id: "seed-proposal-worksheet",
+            kind: "worksheet",
+            title: "Organelle Functions Quiz (10 MCQs)",
+            status: "approved",
+            createdId: geneticsWorksheet.id,
+            payload: {
+                title: "Organelle Functions Quiz (10 MCQs)",
+                questions: Array.from({ length: 10 }, (_, i) => ({
+                    type: "MULTIPLE_CHOICE",
+                    question: `Organelle question ${i + 1}`,
+                    answer: "A",
+                    options: [],
+                    markScheme: [],
+                    points: 1,
+                    order: i,
+                })),
+            },
+        },
+        {
+            id: "seed-proposal-assignment",
+            kind: "assignment",
+            title: "Organelle Functions Quiz",
+            status: "pending",
+            payload: {
+                title: "Organelle Functions Quiz",
+                instructions:
+                    "Complete the 10-question multiple choice quiz on organelle functions. One attempt, 20 minutes.",
+                dueDate: hoursFromNow(7 * 24, now).toISOString(),
+                acceptFiles: false,
+                acceptExtendedResponse: false,
+                acceptWorksheet: true,
+                maxGrade: 10,
+                worksheetIds: [],
+                studentIds: [],
+                type: "QUIZ",
+                attachments: [],
+            },
+        },
+        {
+            id: "seed-proposal-section",
+            kind: "section",
+            title: "Unit 3: Cell Structure",
+            status: "dismissed",
+            payload: { name: "Unit 3: Cell Structure" },
+        },
+        {
+            id: "seed-proposal-assignment-update",
+            kind: "assignmentUpdate",
+            title: geneticsAssignment.title,
+            status: "pending",
+            payload: {
+                id: geneticsAssignment.id,
+                targetTitle: geneticsAssignment.title,
+                dueDate: hoursFromNow(10 * 24, now).toISOString(),
+                maxGrade: 15,
+            },
+        },
+    ];
     await prisma.message.create({
         data: {
-            content:
-                "Sure! Here are 10 AP-level MCQs on organelle functions, with explanations on each. Want me to also generate a 4-criterion rubric for grading short-answer follow-ups?",
+            content: labIntroText,
             senderId: aiUserId,
             conversationId: labConversation.id,
             createdAt: hoursFromNow(-2.95, now),
             status: JobStatus.COMPLETED,
+            meta: {
+                pendingCreations: labProposals,
+                streamParts: [
+                    { type: "text", text: labIntroText },
+                    {
+                        type: "tool",
+                        toolCallId: "seed-tool-worksheet",
+                        toolName: "propose_worksheet",
+                        title: "Organelle Functions Quiz (10 MCQs)",
+                        proposalId: "seed-proposal-worksheet",
+                        status: "completed",
+                    },
+                    {
+                        type: "tool",
+                        toolCallId: "seed-tool-assignment",
+                        toolName: "propose_assignment",
+                        title: "Organelle Functions Quiz",
+                        proposalId: "seed-proposal-assignment",
+                        status: "completed",
+                    },
+                    {
+                        type: "tool",
+                        toolCallId: "seed-tool-section",
+                        toolName: "propose_section",
+                        title: "Unit 3: Cell Structure",
+                        proposalId: "seed-proposal-section",
+                        status: "completed",
+                    },
+                    {
+                        type: "tool",
+                        toolCallId: "seed-tool-assignment-update",
+                        toolName: "propose_update_assignment",
+                        title: geneticsAssignment.title,
+                        proposalId: "seed-proposal-assignment-update",
+                        status: "completed",
+                    },
+                    {
+                        type: "text",
+                        text: "Approve whichever you'd like me to create — nothing is added to the class until you do.",
+                    },
+                ],
+            },
         },
     });
 

package/src/services/adminClass.ts

@@ -0,0 +1,222 @@
+import type { Prisma } from '@prisma/client';
+import { TRPCError } from '@trpc/server';
+import { prisma } from '../lib/prisma.js';
+import { classifyUser } from './adminSpam.js';
+
+export type AdminClassMembership = 'all' | 'populated' | 'empty';
+export type AdminClassSort = 'name' | 'students' | 'assignments';
+
+export async function listClassesForAdmin(input: {
+  page: number;
+  pageSize: number;
+  query?: string;
+  schoolId?: string;
+  membership?: AdminClassMembership;
+  sort?: AdminClassSort;
+}) {
+  const skip = input.page * input.pageSize;
+  const filters: Prisma.ClassWhereInput[] = [];
+
+  const q = input.query?.trim();
+  if (q) {
+    filters.push({
+      OR: [
+        { name: { contains: q, mode: 'insensitive' } },
+        { subject: { contains: q, mode: 'insensitive' } },
+        { section: { contains: q, mode: 'insensitive' } },
+      ],
+    });
+  }
+
+  if (input.schoolId) filters.push({ schoolId: input.schoolId });
+  if (input.membership === 'populated') filters.push({ students: { some: {} } });
+  if (input.membership === 'empty') filters.push({ students: { none: {} } });
+
+  const where: Prisma.ClassWhereInput = filters.length ? { AND: filters } : {};
+
+  const orderBy: Prisma.ClassOrderByWithRelationInput[] =
+    input.sort === 'students'
+      ? [{ students: { _count: 'desc' } }, { name: 'asc' }]
+      : input.sort === 'assignments'
+        ? [{ assignments: { _count: 'desc' } }, { name: 'asc' }]
+        : [{ name: 'asc' }];
+
+  const [items, total] = await Promise.all([
+    prisma.class.findMany({
+      where,
+      orderBy,
+      skip,
+      take: input.pageSize,
+      select: {
+        id: true,
+        name: true,
+        subject: true,
+        section: true,
+        school: { select: { id: true, name: true } },
+        department: { select: { id: true, name: true } },
+        teachers: { select: { id: true, username: true }, take: 3 },
+        assignments: {
+          orderBy: { createdAt: 'desc' },
+          take: 1,
+          select: { createdAt: true },
+        },
+        _count: {
+          select: {
+            students: true,
+            teachers: true,
+            assignments: true,
+            announcements: true,
+            discussions: true,
+            worksheets: true,
+            events: true,
+            modules: true,
+          },
+        },
+      },
+    }),
+    prisma.class.count({ where }),
+  ]);
+
+  return {
+    items: items.map(({ assignments, ...rest }) => ({
+      ...rest,
+      lastAssignmentAt: assignments[0]?.createdAt ?? null,
+    })),
+    total,
+    page: input.page,
+    pageSize: input.pageSize,
+    pageCount: Math.max(1, Math.ceil(total / input.pageSize)),
+  };
+}
+
+const MEMBER_SELECT = {
+  id: true,
+  username: true,
+  email: true,
+  verified: true,
+  _count: { select: { teacherIn: true, studentIn: true, submissions: true } },
+} satisfies Prisma.UserSelect;
+
+export async function getClassForAdmin(id: string) {
+  const cls = await prisma.class.findUnique({
+    where: { id },
+    select: {
+      id: true,
+      name: true,
+      subject: true,
+      section: true,
+      color: true,
+      school: { select: { id: true, name: true } },
+      department: { select: { id: true, name: true } },
+      teachers: { orderBy: { username: 'asc' }, select: MEMBER_SELECT },
+      students: {
+        orderBy: { username: 'asc' },
+        take: 200,
+        select: MEMBER_SELECT,
+      },
+      assignments: {
+        orderBy: { createdAt: 'desc' },
+        take: 20,
+        select: {
+          id: true,
+          title: true,
+          type: true,
+          graded: true,
+          dueDate: true,
+          createdAt: true,
+          teacher: { select: { id: true, username: true } },
+          _count: { select: { submissions: true } },
+        },
+      },
+      announcements: {
+        orderBy: { createdAt: 'desc' },
+        take: 10,
+        select: {
+          id: true,
+          createdAt: true,
+          remarks: true,
+          teacher: { select: { id: true, username: true } },
+        },
+      },
+      _count: {
+        select: {
+          students: true,
+          teachers: true,
+          assignments: true,
+          announcements: true,
+          discussions: true,
+          worksheets: true,
+          events: true,
+          modules: true,
+          sections: true,
+        },
+      },
+    },
+  });
+
+  if (!cls) {
+    throw new TRPCError({ code: 'NOT_FOUND', message: 'Class not found' });
+  }
+
+  // Per-student submission counts scoped to this class, so a roster row shows
+  // engagement here rather than platform-wide totals.
+  const submissionsByStudent = await prisma.submission.groupBy({
+    by: ['studentId'],
+    where: { assignment: { classId: id } },
+    _count: { _all: true },
+  });
+  const submissionCount = new Map(
+    submissionsByStudent.map((row) => [row.studentId, row._count._all]),
+  );
+
+  const withSignals = (user: (typeof cls.students)[number]) => ({
+    ...user,
+    signals: classifyUser(user),
+    submissionsInClass: submissionCount.get(user.id) ?? 0,
+  });
+
+  return {
+    ...cls,
+    teachers: cls.teachers.map(withSignals),
+    students: cls.students.map(withSignals),
+    announcements: cls.announcements.map((announcement) => ({
+      ...announcement,
+      remarks:
+        announcement.remarks.length > 160
+          ? `${announcement.remarks.slice(0, 160)}…`
+          : announcement.remarks,
+    })),
+    suspectedMembers: [...cls.teachers, ...cls.students].filter(
+      (user) => classifyUser(user).suspected,
+    ).length,
+  };
+}
+
+/** Classes a single user teaches or studies in, for the user detail page. */
+export async function listClassesForUserForAdmin(userId: string) {
+  const select = {
+    id: true,
+    name: true,
+    subject: true,
+    section: true,
+    school: { select: { id: true, name: true } },
+    _count: { select: { students: true, assignments: true } },
+  } satisfies Prisma.ClassSelect;
+
+  const [teaching, enrolled] = await Promise.all([
+    prisma.class.findMany({
+      where: { teachers: { some: { id: userId } } },
+      orderBy: { name: 'asc' },
+      take: 100,
+      select,
+    }),
+    prisma.class.findMany({
+      where: { students: { some: { id: userId } } },
+      orderBy: { name: 'asc' },
+      take: 100,
+      select,
+    }),
+  ]);
+
+  return { teaching, enrolled };
+}

package/src/services/adminInstitution.ts

@@ -1,6 +1,7 @@
 import type { Prisma } from '@prisma/client';
 import { TRPCError } from '@trpc/server';
 import { prisma } from '../lib/prisma.js';
+import { classifyEmail } from './adminSpam.js';
 
 export async function listSchoolsForAdmin(input: {
   page: number;
@@ -159,7 +160,10 @@ export async function listSchoolDevelopmentProgramsForAdmin(input: {
   ]);
 
   return {
-    items,
+    items: items.map((item) => ({
+      ...item,
+      signals: classifyEmail(item.contactEmail),
+    })),
     total,
     page: input.page,
     pageSize: input.pageSize,
@@ -183,7 +187,10 @@ export async function listEarlyAccessRequestsForAdmin(input: {
   ]);
 
   return {
-    items,
+    items: items.map((item) => ({
+      ...item,
+      signals: classifyEmail(item.email),
+    })),
     total,
     page: input.page,
     pageSize: input.pageSize,

package/src/services/adminMetrics.ts

@@ -1,13 +1,31 @@
 import { prisma } from '../lib/prisma.js';
+import { suspectedUserWhere } from './adminSpam.js';
+
+async function countActiveUsersSince(since: Date) {
+  const rows = await prisma.session.groupBy({
+    by: ['userId'],
+    where: { type: 'AUTH', createdAt: { gte: since }, userId: { not: null } },
+  });
+  return rows.length;
+}
 
 export async function getOverviewMetricsForAdmin() {
   const dayAgo = new Date(Date.now() - 24 * 60 * 60 * 1000);
+  const weekAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
+  const suspected = suspectedUserWhere();
 
   const [
     schools,
     users,
     verifiedUsers,
+    suspectedUsers,
+    signupsLast24h,
+    signupsLast7d,
+    activeUsersLast24h,
+    activeUsersLast7d,
     classes,
+    activeClassesLast7d,
+    submissionsLast24h,
     departments,
     runJobsByStatus,
     failedRunJobsLast24h,
@@ -17,7 +35,16 @@ export async function getOverviewMetricsForAdmin() {
     prisma.school.count(),
     prisma.user.count(),
     prisma.user.count({ where: { verified: true } }),
+    prisma.user.count({ where: suspected }),
+    prisma.userProfile.count({ where: { createdAt: { gte: dayAgo } } }),
+    prisma.userProfile.count({ where: { createdAt: { gte: weekAgo } } }),
+    countActiveUsersSince(dayAgo),
+    countActiveUsersSince(weekAgo),
     prisma.class.count(),
+    prisma.class.count({
+      where: { assignments: { some: { createdAt: { gte: weekAgo } } } },
+    }),
+    prisma.submission.count({ where: { submittedAt: { gte: dayAgo } } }),
     prisma.department.count(),
     prisma.runJob.groupBy({ by: ['status'], _count: { _all: true } }),
     prisma.runJob.count({
@@ -31,6 +58,14 @@ export async function getOverviewMetricsForAdmin() {
     schools,
     users,
     verifiedUsers,
+    suspectedUsers,
+    cleanUsers: users - suspectedUsers,
+    signupsLast24h,
+    signupsLast7d,
+    activeUsersLast24h,
+    activeUsersLast7d,
+    activeClassesLast7d,
+    submissionsLast24h,
     classes,
     departments,
     runJobs: {