@studious-lms/server 1.13.0 → 1.15.0

package/src/services/discussion.ts

@@ -1,10 +1,12 @@
 import type { DiscussionType, Prisma, ReactionType } from "@prisma/client";
+import type { AppTransactionClient } from "../lib/prisma.js";
 import { TRPCError } from "@trpc/server";
 import { prisma } from "../lib/prisma.js";
 import { discussionChannel, pusher } from "../lib/pusher.js";
 import { logger } from "../utils/logger.js";
 import { classMemberOrSchoolAdminWhere, classTeacherOrSchoolAdminWhere } from "../models/access.js";
 import { sendNotification } from "./notification.js";
+import { enqueueEmbedding } from "./embedding.js";
 
 const authorSelect = {
   id: true,
@@ -225,7 +227,7 @@ async function getDiscussionForUser(discussionId: string, userId: string) {
 }
 
 async function claimDiscussionAttachments(
-  tx: Prisma.TransactionClient,
+  tx: AppTransactionClient,
   userId: string,
   discussionId: string,
   attachmentIds: string[] = []
@@ -242,7 +244,7 @@ async function claimDiscussionAttachments(
 }
 
 async function claimReplyAttachments(
-  tx: Prisma.TransactionClient,
+  tx: AppTransactionClient,
   userId: string,
   replyId: string,
   attachmentIds: string[] = []
@@ -440,6 +442,10 @@ export async function createDiscussion(userId: string, input: {
 
   triggerDiscussionEvent(input.classId, "discussion-created", { discussion: serializeDiscussion(discussion, userId) });
   await notifyMentionedUsers(input.classId, userId, input.body, `/class/${input.classId}/discussions/${discussion.id}`);
+
+  // Auto-index discussion for RAG search
+  enqueueEmbedding(input.classId, 'DISCUSSION', discussion.id);
+
   return { discussion: serializeDiscussion(discussion, userId) };
 }
 
@@ -470,6 +476,10 @@ export async function updateDiscussion(userId: string, input: {
     include: discussionInclude,
   });
   triggerDiscussionEvent(updated.classId, "discussion-updated", { discussion: serializeDiscussion(updated, userId) });
+
+  // Re-index discussion for RAG search after update
+  enqueueEmbedding(updated.classId, 'DISCUSSION', updated.id);
+
   return { discussion: serializeDiscussion(updated, userId) };
 }
 
@@ -525,6 +535,10 @@ export async function replyToDiscussion(userId: string, input: {
     notifyMentionedUsers(discussion.classId, userId, input.body, link),
   ]);
   triggerDiscussionEvent(discussion.classId, "reply-created", { discussionId: discussion.id, reply: serializeReply(reply, userId) });
+
+  // Re-index discussion for RAG search (includes new reply)
+  enqueueEmbedding(discussion.classId, 'DISCUSSION', discussion.id);
+
   return { reply: serializeReply(reply, userId) };
 }
 
@@ -674,28 +688,28 @@ export async function toggleDiscussionReaction(userId: string, input: { discussi
 
 export async function listDiscussionTags(userId: string, classId: string) {
   await getDiscussionClassAccess(classId, userId);
-  return prisma.discussionTag.findMany({ where: { classId }, orderBy: { name: "asc" } });
+  return prisma.classTag.findMany({ where: { classId }, orderBy: { name: "asc" } });
 }
 
 export async function createDiscussionTag(userId: string, input: { classId: string; name: string; color: string }) {
   const isTeacher = await prisma.class.findFirst({ where: { id: input.classId, ...classTeacherOrSchoolAdminWhere(userId) }, select: { id: true, discussionsEnabled: true } });
   if (!isTeacher?.discussionsEnabled) throw new TRPCError({ code: "FORBIDDEN", message: "Only teachers can manage discussion tags" });
-  return prisma.discussionTag.create({ data: { classId: input.classId, name: input.name.trim(), color: input.color } });
+  return prisma.classTag.create({ data: { classId: input.classId, name: input.name.trim(), color: input.color } });
 }
 
 export async function updateDiscussionTag(userId: string, input: { tagId: string; name?: string; color?: string }) {
-  const tag = await prisma.discussionTag.findUnique({ where: { id: input.tagId }, select: { classId: true } });
+  const tag = await prisma.classTag.findUnique({ where: { id: input.tagId }, select: { classId: true } });
   if (!tag) throw new TRPCError({ code: "NOT_FOUND", message: "Tag not found" });
   const isTeacher = await prisma.class.findFirst({ where: { id: tag.classId, ...classTeacherOrSchoolAdminWhere(userId) }, select: { id: true, discussionsEnabled: true } });
   if (!isTeacher?.discussionsEnabled) throw new TRPCError({ code: "FORBIDDEN", message: "Only teachers can manage discussion tags" });
-  return prisma.discussionTag.update({ where: { id: input.tagId }, data: { name: input.name?.trim(), color: input.color } });
+  return prisma.classTag.update({ where: { id: input.tagId }, data: { name: input.name?.trim(), color: input.color } });
 }
 
 export async function deleteDiscussionTag(userId: string, tagId: string) {
-  const tag = await prisma.discussionTag.findUnique({ where: { id: tagId }, select: { classId: true } });
+  const tag = await prisma.classTag.findUnique({ where: { id: tagId }, select: { classId: true } });
   if (!tag) throw new TRPCError({ code: "NOT_FOUND", message: "Tag not found" });
   const isTeacher = await prisma.class.findFirst({ where: { id: tag.classId, ...classTeacherOrSchoolAdminWhere(userId) }, select: { id: true, discussionsEnabled: true } });
   if (!isTeacher?.discussionsEnabled) throw new TRPCError({ code: "FORBIDDEN", message: "Only teachers can manage discussion tags" });
-  await prisma.discussionTag.delete({ where: { id: tagId } });
+  await prisma.classTag.delete({ where: { id: tagId } });
   return { success: true };
 }

package/src/services/discussionSummary.ts

@@ -0,0 +1,226 @@
+/**
+ * AI-powered discussion summary service with in-memory + Redis caching.
+ */
+import { prisma } from "../lib/prisma.js";
+import { getRedis } from "../lib/redis.js";
+import { inference } from "../utils/inference.js";
+import { logger } from "../utils/logger.js";
+import { TRPCError } from "@trpc/server";
+import { z } from "zod";
+import { classMemberOrSchoolAdminWhere } from "../models/access.js";
+
+const discussionSummarySchema = z.object({
+  summary: z
+    .string()
+    .describe("A concise 2-4 sentence TL;DR of the entire discussion thread."),
+  keyQuestions: z
+    .array(z.string())
+    .describe("Up to 5 important student questions raised in the thread."),
+  unresolvedIssues: z
+    .array(z.string())
+    .describe(
+      "Up to 3 questions or topics that remain unanswered or unresolved.",
+    ),
+  participantCount: z
+    .number()
+    .describe("Number of unique participants in the thread."),
+});
+
+export type DiscussionSummary = z.infer<typeof discussionSummarySchema>;
+
+const REDIS_PREFIX = "discussionSummary:";
+const REDIS_TTL_SECONDS = 60 * 30; // 30 min
+
+const memoryCache = new Map<
+  string,
+  { value: DiscussionSummary; replyCount: number; cachedAt: number }
+>();
+const MEMORY_TTL_MS = 10 * 60 * 1000; // 10 min
+
+function memoryCacheKey(discussionId: string) {
+  return discussionId;
+}
+
+function getMemoryCacheHit(
+  discussionId: string,
+  currentReplyCount: number,
+): DiscussionSummary | undefined {
+  const entry = memoryCache.get(memoryCacheKey(discussionId));
+  if (!entry) return undefined;
+  if (Date.now() - entry.cachedAt > MEMORY_TTL_MS) {
+    memoryCache.delete(memoryCacheKey(discussionId));
+    return undefined;
+  }
+  if (entry.replyCount !== currentReplyCount) {
+    memoryCache.delete(memoryCacheKey(discussionId));
+    return undefined;
+  }
+  return entry.value;
+}
+
+function setMemoryCache(
+  discussionId: string,
+  value: DiscussionSummary,
+  replyCount: number,
+) {
+  memoryCache.set(memoryCacheKey(discussionId), {
+    value,
+    replyCount,
+    cachedAt: Date.now(),
+  });
+}
+
+async function getRedisCacheHit(
+  discussionId: string,
+  currentReplyCount: number,
+): Promise<DiscussionSummary | undefined> {
+  const redis = getRedis();
+  if (!redis) return undefined;
+  try {
+    const raw = await redis.get(`${REDIS_PREFIX}${discussionId}`);
+    if (!raw) return undefined;
+    const parsed = JSON.parse(raw) as {
+      value: DiscussionSummary;
+      replyCount: number;
+    };
+    if (parsed.replyCount !== currentReplyCount) return undefined;
+    return parsed.value;
+  } catch {
+    return undefined;
+  }
+}
+
+async function setRedisCache(
+  discussionId: string,
+  value: DiscussionSummary,
+  replyCount: number,
+) {
+  const redis = getRedis();
+  if (!redis) return;
+  try {
+    await redis.set(
+      `${REDIS_PREFIX}${discussionId}`,
+      JSON.stringify({ value, replyCount }),
+      "EX",
+      REDIS_TTL_SECONDS,
+    );
+  } catch (err) {
+    logger.error("Failed to cache discussion summary in Redis", { err });
+  }
+}
+
+export async function getDiscussionSummary(
+  userId: string,
+  discussionId: string,
+): Promise<DiscussionSummary> {
+  const discussion = await prisma.discussion.findUnique({
+    where: { id: discussionId },
+    select: {
+      id: true,
+      classId: true,
+      title: true,
+      body: true,
+      type: true,
+      replies: {
+        where: { deletedAt: null },
+        select: {
+          body: true,
+          author: {
+            select: {
+              username: true,
+              profile: { select: { displayName: true } },
+            },
+          },
+          createdAt: true,
+        },
+        orderBy: { createdAt: "asc" },
+      },
+      author: {
+        select: {
+          username: true,
+          profile: { select: { displayName: true } },
+        },
+      },
+    },
+  });
+
+  if (!discussion) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Discussion not found",
+    });
+  }
+
+  // Verify user is a member of the class
+  const classMembership = await prisma.class.findFirst({
+    where: { id: discussion.classId, ...classMemberOrSchoolAdminWhere(userId) },
+    select: { id: true },
+  });
+  if (!classMembership) {
+    throw new TRPCError({
+      code: "UNAUTHORIZED",
+      message: "You are not a member of this class",
+    });
+  }
+
+  const replyCount = discussion.replies.length;
+
+  // Check memory cache
+  const memoryCached = getMemoryCacheHit(discussionId, replyCount);
+  if (memoryCached) return memoryCached;
+
+  // Check Redis cache
+  const redisCached = await getRedisCacheHit(discussionId, replyCount);
+  if (redisCached) {
+    setMemoryCache(discussionId, redisCached, replyCount);
+    return redisCached;
+  }
+
+  // Build context for inference
+  const authorName =
+    discussion.author.profile?.displayName ?? discussion.author.username;
+  const threadText = [
+    `Title: ${discussion.title}`,
+    `Type: ${discussion.type}`,
+    `Author: ${authorName}`,
+    `Original post:\n${discussion.body}`,
+    "",
+    ...discussion.replies.map((reply, i) => {
+      const name =
+        reply.author.profile?.displayName ?? reply.author.username;
+      return `Reply ${i + 1} by ${name}:\n${reply.body}`;
+    }),
+  ].join("\n\n");
+
+  const messages = [
+    {
+      role: "system" as const,
+      content:
+        "You are a helpful assistant summarizing a class discussion thread for a teacher. Be concise, specific, and grounded in the actual content. Do not fabricate information.",
+    },
+    {
+      role: "user" as const,
+      content: threadText,
+    },
+    {
+      role: "user" as const,
+      content:
+        "Generate a structured summary of this discussion thread. Include a TL;DR, key student questions, and any unresolved issues.",
+    },
+  ];
+
+  const result = await inference<DiscussionSummary>(
+    messages,
+    discussionSummarySchema,
+    {
+      reason: "discussion_summary",
+      metadata: { discussionId, classId: discussion.classId },
+    },
+  );
+
+  // Cache result
+  setMemoryCache(discussionId, result, replyCount);
+  await setRedisCache(discussionId, result, replyCount);
+
+  return result;
+}