@studious-lms/server 1.12.0 → 1.14.0

package/src/routers/discussion.ts

@@ -21,6 +21,7 @@ import {
   updateDiscussionReply,
   updateDiscussionTag,
 } from "../services/discussion.js";
+import { getDiscussionSummary } from "../services/discussionSummary.js";
 import { confirmDirectUpload, createDirectUploadFiles } from "../lib/fileUpload.js";
 import { prisma } from "../lib/prisma.js";
 import { TRPCError } from "@trpc/server";
@@ -185,6 +186,12 @@ export const discussionRouter = createTRPCRouter({
       .mutation(({ ctx, input }) => toggleDiscussionReaction(ctx.user!.id, input)),
   }),
 
+  summarize: protectedProcedure
+    .input(z.object({ discussionId: z.string() }))
+    .query(({ ctx, input }) =>
+      getDiscussionSummary(ctx.user!.id, input.discussionId),
+    ),
+
   tags: createTRPCRouter({
     list: protectedProcedure
       .input(z.object({ classId: z.string() }))

package/src/routers/embedding.ts

@@ -0,0 +1,159 @@
+/**
+ * tRPC router for embedding/RAG operations.
+ * Provides search and indexing triggers for class content.
+ */
+import { z } from 'zod';
+import { createTRPCRouter, protectedProcedure } from '../trpc.js';
+import { searchEmbeddings, indexAssignment, indexWorksheet, indexAnnouncement } from '../services/embedding.js';
+import { enqueueRunJob } from '../workers/queues.js';
+import { prisma } from '../lib/prisma.js';
+import { TRPCError } from '@trpc/server';
+import type { EmbeddingSourceType } from '@prisma/client';
+
+export const embeddingRouter = createTRPCRouter({
+  /**
+   * Semantic search over class materials.
+   */
+  search: protectedProcedure
+    .input(z.object({
+      classId: z.string(),
+      query: z.string().min(1).max(500),
+      limit: z.number().min(1).max(20).default(5),
+      sourceTypes: z.array(z.enum(['FILE', 'ASSIGNMENT', 'WORKSHEET', 'ANNOUNCEMENT', 'SECTION'])).optional(),
+    }))
+    .query(async ({ input, ctx }) => {
+      // Verify user has access to the class
+      const userInClass = await prisma.class.findFirst({
+        where: {
+          id: input.classId,
+          OR: [
+            { teachers: { some: { id: ctx.user!.id } } },
+            { students: { some: { id: ctx.user!.id } } },
+          ],
+        },
+      });
+
+      if (!userInClass) {
+        throw new TRPCError({ code: 'FORBIDDEN', message: 'Access denied' });
+      }
+
+      const results = await searchEmbeddings({
+        classId: input.classId,
+        query: input.query,
+        limit: input.limit,
+        sourceTypes: input.sourceTypes as EmbeddingSourceType[] | undefined,
+      });
+
+      return results;
+    }),
+
+  /**
+   * Trigger re-indexing of a specific resource.
+   * Teachers only.
+   */
+  reindex: protectedProcedure
+    .input(z.object({
+      classId: z.string(),
+      sourceType: z.enum(['FILE', 'ASSIGNMENT', 'WORKSHEET', 'ANNOUNCEMENT', 'SECTION']),
+      sourceId: z.string(),
+    }))
+    .mutation(async ({ input, ctx }) => {
+      // Verify teacher access
+      const teacherInClass = await prisma.class.findFirst({
+        where: {
+          id: input.classId,
+          teachers: { some: { id: ctx.user!.id } },
+        },
+      });
+
+      if (!teacherInClass) {
+        throw new TRPCError({ code: 'FORBIDDEN', message: 'Teacher access required' });
+      }
+
+      const result = await enqueueRunJob('EMBED_CONTENT', {
+        classId: input.classId,
+        sourceType: input.sourceType,
+        sourceId: input.sourceId,
+      }, {
+        classId: input.classId,
+        userId: ctx.user!.id,
+      });
+
+      return { runJobId: result.runJobId };
+    }),
+
+  /**
+   * Bulk index all content for a class.
+   * Teachers only. Useful for initial setup.
+   */
+  indexAll: protectedProcedure
+    .input(z.object({
+      classId: z.string(),
+    }))
+    .mutation(async ({ input, ctx }) => {
+      const teacherInClass = await prisma.class.findFirst({
+        where: {
+          id: input.classId,
+          teachers: { some: { id: ctx.user!.id } },
+        },
+      });
+
+      if (!teacherInClass) {
+        throw new TRPCError({ code: 'FORBIDDEN', message: 'Teacher access required' });
+      }
+
+      // Enqueue all assignments
+      const assignments = await prisma.assignment.findMany({
+        where: { classId: input.classId },
+        select: { id: true },
+      });
+
+      // Enqueue all worksheets
+      const worksheets = await prisma.worksheet.findMany({
+        where: { classId: input.classId },
+        select: { id: true },
+      });
+
+      // Enqueue all announcements
+      const announcements = await prisma.announcement.findMany({
+        where: { classId: input.classId },
+        select: { id: true },
+      });
+
+      const jobs: Promise<unknown>[] = [];
+
+      for (const a of assignments) {
+        jobs.push(enqueueRunJob('EMBED_CONTENT', {
+          classId: input.classId,
+          sourceType: 'ASSIGNMENT',
+          sourceId: a.id,
+        }, { classId: input.classId, userId: ctx.user!.id }));
+      }
+
+      for (const w of worksheets) {
+        jobs.push(enqueueRunJob('EMBED_CONTENT', {
+          classId: input.classId,
+          sourceType: 'WORKSHEET',
+          sourceId: w.id,
+        }, { classId: input.classId, userId: ctx.user!.id }));
+      }
+
+      for (const ann of announcements) {
+        jobs.push(enqueueRunJob('EMBED_CONTENT', {
+          classId: input.classId,
+          sourceType: 'ANNOUNCEMENT',
+          sourceId: ann.id,
+        }, { classId: input.classId, userId: ctx.user!.id }));
+      }
+
+      await Promise.allSettled(jobs);
+
+      return {
+        queued: {
+          assignments: assignments.length,
+          worksheets: worksheets.length,
+          announcements: announcements.length,
+        },
+      };
+    }),
+});

package/src/routers/search.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { createTRPCRouter, protectedProcedure } from "../trpc.js";
-import { searchGlobalClasses } from "../services/search.js";
+import { searchGlobalClasses, searchSemanticGlobal } from "../services/search.js";
 
 export const searchRouter = createTRPCRouter({
   global: protectedProcedure
@@ -11,4 +11,13 @@ export const searchRouter = createTRPCRouter({
       })
     )
     .query(({ ctx, input }) => searchGlobalClasses(ctx.user!.id, input)),
+
+  semantic: protectedProcedure
+    .input(
+      z.object({
+        query: z.string().min(1).max(200),
+        limit: z.number().int().min(1).max(30).optional(),
+      })
+    )
+    .query(({ ctx, input }) => searchSemanticGlobal(ctx.user!.id, input)),
 });

package/src/routers/worksheet.ts

@@ -233,6 +233,7 @@ export const worksheetRouter = createTRPCRouter({
           "MATH_EXPRESSION",
           "ESSAY",
         ]),
+        order: z.number().int().min(0).optional(),
       })
     )
     .mutation(({ ctx, input }) =>
@@ -243,6 +244,7 @@ export const worksheetRouter = createTRPCRouter({
         options: input.options,
         markScheme: input.markScheme,
         type: input.type,
+        order: input.order,
       })
     ),
 
@@ -443,4 +445,31 @@ export const worksheetRouter = createTRPCRouter({
         progress: input.progress,
       };
     }),
+
+  setTags: protectedTeacherProcedure
+    .input(
+      z.object({
+        worksheetId: z.string(),
+        tagIds: z.array(z.string()),
+      }),
+    )
+    .mutation(async ({ ctx, input }) => {
+      const worksheet = await prisma.worksheet.findUnique({
+        where: { id: input.worksheetId },
+        select: { id: true, classId: true },
+      });
+      if (!worksheet) {
+        throw new TRPCError({
+          code: "NOT_FOUND",
+          message: "Worksheet not found",
+        });
+      }
+      return prisma.worksheet.update({
+        where: { id: input.worksheetId },
+        data: {
+          tags: { set: input.tagIds.map((id) => ({ id })) },
+        },
+        include: { tags: true },
+      });
+    }),
 });