@studious-lms/server 1.4.3 → 1.4.5

package/src/services/search.ts

@@ -0,0 +1,397 @@
+import { prisma } from "../lib/prisma.js";
+
+type SearchScope =
+  | "class"
+  | "assignment"
+  | "event"
+  | "syllabus"
+  | "worksheet"
+  | "file"
+  | "announcement"
+  | "section";
+
+type SearchResult = {
+  id: string;
+  type: SearchScope;
+  title: string;
+  subtitle: string;
+  classId: string;
+  className: string;
+  href: string;
+  matchedText?: string | null;
+  date?: Date | null;
+};
+
+const SEARCH_LIMIT = 12;
+
+const contains = (query: string) => ({
+  contains: query,
+  mode: "insensitive" as const,
+});
+
+const includesToken = (query: string, ...tokens: string[]) =>
+  tokens.some((token) => token.includes(query.toLowerCase()));
+
+const excerpt = (value: string | null | undefined, query: string) => {
+  if (!value) return null;
+  const trimmed = value.replace(/\s+/g, " ").trim();
+  if (!trimmed) return null;
+  if (!query) return trimmed.slice(0, 140);
+
+  const index = trimmed.toLowerCase().indexOf(query.toLowerCase());
+  if (index < 0) return trimmed.slice(0, 140);
+
+  const start = Math.max(0, index - 48);
+  const end = Math.min(trimmed.length, index + query.length + 92);
+  return `${start > 0 ? "..." : ""}${trimmed.slice(start, end)}${end < trimmed.length ? "..." : ""}`;
+};
+
+const trimResults = (results: SearchResult[], limit: number) =>
+  results
+    .sort((a, b) => {
+      const priority: Record<SearchScope, number> = {
+        class: 0,
+        assignment: 1,
+        event: 2,
+        syllabus: 3,
+        worksheet: 4,
+        file: 5,
+        announcement: 6,
+        section: 7,
+      };
+      const priorityDiff = priority[a.type] - priority[b.type];
+      if (priorityDiff !== 0) return priorityDiff;
+      return (b.date?.getTime() ?? 0) - (a.date?.getTime() ?? 0);
+    })
+    .slice(0, limit);
+
+export async function searchGlobalClasses(
+  userId: string,
+  input: { query?: string; limit?: number }
+) {
+  const rawQuery = input.query?.trim() ?? "";
+  const query = rawQuery.slice(0, 80);
+  const limit = Math.min(Math.max(input.limit ?? SEARCH_LIMIT, 1), 30);
+
+  const memberships = await prisma.class.findMany({
+    where: {
+      OR: [
+        { teachers: { some: { id: userId } } },
+        { students: { some: { id: userId } } },
+      ],
+    },
+    select: {
+      id: true,
+      name: true,
+      section: true,
+      subject: true,
+      syllabus: true,
+      teachers: { where: { id: userId }, select: { id: true } },
+      students: { where: { id: userId }, select: { id: true } },
+    },
+  });
+
+  const allClassIds = memberships.map((cls) => cls.id);
+  if (allClassIds.length === 0) {
+    return { query, results: [] as SearchResult[] };
+  }
+
+  const teacherClassIds = memberships
+    .filter((cls) => cls.teachers.length > 0)
+    .map((cls) => cls.id);
+  const studentClassIds = memberships
+    .filter((cls) => cls.students.length > 0 && cls.teachers.length === 0)
+    .map((cls) => cls.id);
+  const classById = new Map(memberships.map((cls) => [cls.id, cls]));
+
+  const queryFilters = query
+    ? {
+        class: [
+          { name: contains(query) },
+          { section: contains(query) },
+          { subject: contains(query) },
+        ],
+        assignment: [
+          { title: contains(query) },
+          { instructions: contains(query) },
+        ],
+        event: [
+          { name: contains(query) },
+          { location: contains(query) },
+          { remarks: contains(query) },
+        ],
+        worksheet: [{ name: contains(query) }],
+        file: [{ name: contains(query) }, { type: contains(query) }],
+        announcement: [{ remarks: contains(query) }],
+        section: [{ name: contains(query) }],
+      }
+    : null;
+
+  const assignmentAccess = [
+    ...(teacherClassIds.length > 0
+      ? [{ classId: { in: teacherClassIds } }]
+      : []),
+    ...(studentClassIds.length > 0
+      ? [
+          {
+            classId: { in: studentClassIds },
+            OR: [
+              { assignedTo: { some: { id: userId } } },
+              { assignedTo: { none: {} } },
+            ],
+          },
+        ]
+      : []),
+  ];
+
+  const [
+    classes,
+    assignments,
+    events,
+    worksheets,
+    files,
+    announcements,
+    sections,
+  ] = await Promise.all([
+    prisma.class.findMany({
+      where: {
+        id: { in: allClassIds },
+        ...(queryFilters ? { OR: queryFilters.class } : {}),
+      },
+      select: { id: true, name: true, section: true, subject: true },
+      take: limit,
+    }),
+    prisma.assignment.findMany({
+      where: {
+        template: false,
+        AND: [
+          ...(queryFilters ? [{ OR: queryFilters.assignment }] : []),
+          ...(assignmentAccess.length > 0 ? [{ OR: assignmentAccess }] : []),
+        ],
+      },
+      select: {
+        id: true,
+        title: true,
+        instructions: true,
+        dueDate: true,
+        modifiedAt: true,
+        classId: true,
+        class: { select: { name: true } },
+      },
+      orderBy: { dueDate: "asc" },
+      take: limit,
+    }),
+    prisma.event.findMany({
+      where: {
+        classId: { in: allClassIds },
+        ...(queryFilters ? { OR: queryFilters.event } : {}),
+      },
+      select: {
+        id: true,
+        name: true,
+        location: true,
+        remarks: true,
+        startTime: true,
+        classId: true,
+        class: { select: { name: true } },
+      },
+      orderBy: { startTime: "asc" },
+      take: limit,
+    }),
+    prisma.worksheet.findMany({
+      where: {
+        classId: { in: allClassIds },
+        ...(queryFilters && !includesToken(query, "worksheet", "worksheets")
+          ? { OR: queryFilters.worksheet }
+          : {}),
+      },
+      select: {
+        id: true,
+        name: true,
+        updatedAt: true,
+        classId: true,
+        class: { select: { name: true } },
+      },
+      orderBy: { updatedAt: "desc" },
+      take: limit,
+    }),
+    prisma.file.findMany({
+      where: {
+        ...(queryFilters ? { OR: queryFilters.file } : {}),
+        AND: [
+          {
+            OR: [
+              { folder: { classId: { in: allClassIds } } },
+              { classDraftId: { in: teacherClassIds } },
+              {
+                assignment: {
+                  OR: assignmentAccess,
+                },
+              },
+              { announcement: { classId: { in: allClassIds } } },
+            ],
+          },
+        ],
+      },
+      select: {
+        id: true,
+        name: true,
+        type: true,
+        uploadedAt: true,
+        folder: { select: { classId: true, class: { select: { name: true } } } },
+        classDraft: { select: { id: true, name: true } },
+        assignment: { select: { classId: true, class: { select: { name: true } } } },
+        announcement: { select: { classId: true, class: { select: { name: true } } } },
+      },
+      orderBy: { uploadedAt: "desc" },
+      take: limit,
+    }),
+    prisma.announcement.findMany({
+      where: {
+        classId: { in: allClassIds },
+        ...(queryFilters ? { OR: queryFilters.announcement } : {}),
+      },
+      select: {
+        id: true,
+        remarks: true,
+        createdAt: true,
+        classId: true,
+        class: { select: { name: true } },
+      },
+      orderBy: { createdAt: "desc" },
+      take: limit,
+    }),
+    prisma.section.findMany({
+      where: {
+        classId: { in: allClassIds },
+        ...(queryFilters && !includesToken(query, "section", "sections", "assignment", "assignments")
+          ? { OR: queryFilters.section }
+          : {}),
+      },
+      select: {
+        id: true,
+        name: true,
+        classId: true,
+        class: { select: { name: true } },
+      },
+      take: limit,
+    }),
+  ]);
+
+  const results: SearchResult[] = [
+    ...classes.map((cls) => ({
+      id: cls.id,
+      type: "class" as const,
+      title: cls.name,
+      subtitle: [cls.subject, cls.section].filter(Boolean).join(" · "),
+      classId: cls.id,
+      className: cls.name,
+      href: `/class/${cls.id}`,
+    })),
+    ...assignments.map((assignment) => ({
+      id: assignment.id,
+      type: "assignment" as const,
+      title: assignment.title,
+      subtitle: `${assignment.class.name} · Assignment`,
+      classId: assignment.classId,
+      className: assignment.class.name,
+      href: `/class/${assignment.classId}/assignment/${assignment.id}`,
+      matchedText: excerpt(assignment.instructions, query),
+      date: assignment.dueDate ?? assignment.modifiedAt,
+    })),
+    ...events.map((event) => ({
+      id: event.id,
+      type: "event" as const,
+      title: event.name || "Untitled event",
+      subtitle: `${event.class?.name ?? "Class"} · Event`,
+      classId: event.classId!,
+      className: event.class?.name ?? "Class",
+      href: `/class/${event.classId}/attendance/${event.id}`,
+      matchedText: excerpt(event.location || event.remarks, query),
+      date: event.startTime,
+    })),
+    ...memberships
+      .filter((cls) => {
+        if (!cls.syllabus) return false;
+        if (!query) return true;
+        return (
+          includesToken(query, "syllabus") ||
+          cls.name.toLowerCase().includes(query.toLowerCase()) ||
+          cls.subject.toLowerCase().includes(query.toLowerCase()) ||
+          cls.syllabus.toLowerCase().includes(query.toLowerCase())
+        );
+      })
+      .slice(0, limit)
+      .map((cls) => ({
+        id: `${cls.id}:syllabus`,
+        type: "syllabus" as const,
+        title: `${cls.name} syllabus`,
+        subtitle: `${cls.subject} · Syllabus`,
+        classId: cls.id,
+        className: cls.name,
+        href: `/class/${cls.id}/syllabus`,
+        matchedText: excerpt(cls.syllabus, query),
+      })),
+    ...worksheets.map((worksheet) => ({
+      id: worksheet.id,
+      type: "worksheet" as const,
+      title: worksheet.name,
+      subtitle: `${worksheet.class?.name ?? "Class"} · Worksheet`,
+      classId: worksheet.classId,
+      className: worksheet.class?.name ?? "Class",
+      href: `/class/${worksheet.classId}/worksheets`,
+      date: worksheet.updatedAt,
+    })),
+    ...files.flatMap((file) => {
+      const classId =
+        file.folder?.classId ??
+        file.classDraft?.id ??
+        file.assignment?.classId ??
+        file.announcement?.classId;
+      const className =
+        file.folder?.class?.name ??
+        file.classDraft?.name ??
+        file.assignment?.class?.name ??
+        file.announcement?.class?.name ??
+        (classId ? classById.get(classId)?.name : undefined);
+
+      if (!classId || !className) return [];
+
+      return [
+        {
+          id: file.id,
+          type: "file" as const,
+          title: file.name,
+          subtitle: `${className} · File`,
+          classId,
+          className,
+          href: `/class/${classId}/files`,
+          matchedText: file.type,
+          date: file.uploadedAt,
+        },
+      ];
+    }),
+    ...announcements.map((announcement) => ({
+      id: announcement.id,
+      type: "announcement" as const,
+      title: excerpt(announcement.remarks, query) ?? "Announcement",
+      subtitle: `${announcement.class.name} · Announcement`,
+      classId: announcement.classId,
+      className: announcement.class.name,
+      href: `/class/${announcement.classId}`,
+      matchedText: excerpt(announcement.remarks, query),
+      date: announcement.createdAt,
+    })),
+    ...sections.map((section) => ({
+      id: section.id,
+      type: "section" as const,
+      title: section.name,
+      subtitle: `${section.class.name} · Section`,
+      classId: section.classId,
+      className: section.class.name,
+      href: `/class/${section.classId}/assignments`,
+    })),
+  ];
+
+  return { query, results: trimResults(results, limit) };
+}

package/src/services/worksheet.ts

@@ -5,7 +5,9 @@
 import { TRPCError } from "@trpc/server";
 import { GenerationStatus, type WorksheetQuestionType } from "@prisma/client";
 import { prisma } from "../lib/prisma.js";
+import { getFileUrl } from "../lib/fileUpload.js";
 import { cancelGradePipeline, regradeWorksheetPipeline } from "../pipelines/gradeWorksheet.js";
+import { pdfToWorksheet } from "../pipelines/pdfToWorksheet.js";
 import {
   findWorksheetByIdMinimal,
   findWorksheetByIdForClassMember,
@@ -121,6 +123,65 @@ export async function createWorksheetRecord(classId: string, name: string) {
   return createWorksheet({ classId, name });
 }
 
+/**
+ * Create a worksheet by converting a PDF (URL) into structured questions.
+ * Uses the `pdfToWorksheet` pipeline to do inference + persistence.
+ */
+export async function createWorksheetFromPdf(
+  classId: string,
+  url: string
+) {
+  const created = await pdfToWorksheet(url, classId);
+  if (!created) {
+    throw new TRPCError({
+      code: "INTERNAL_SERVER_ERROR",
+      message: "Failed to create worksheet from PDF",
+    });
+  }
+  return created;
+}
+
+/**
+ * Create a worksheet from a PDF that was uploaded through the direct-upload flow.
+ */
+export async function createWorksheetFromUploadedPdf(
+  classId: string,
+  fileId: string,
+  userId: string
+) {
+  const file = await prisma.file.findFirst({
+    where: {
+      id: fileId,
+      userId,
+      uploadStatus: "COMPLETED",
+    },
+    select: {
+      id: true,
+      path: true,
+      type: true,
+    },
+  });
+
+  if (!file) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Uploaded file not found or not ready",
+    });
+  }
+
+  const isPdf =
+    file.type === "application/pdf" || file.path.toLowerCase().endsWith(".pdf");
+  if (!isPdf) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "Only PDF files can be converted into worksheets",
+    });
+  }
+
+  const signedUrl = await getFileUrl(file.path);
+  return createWorksheetFromPdf(classId, signedUrl);
+}
+
 export async function addQuestionToWorksheet(
   worksheetId: string,
   userId: string,

package/src/utils/inference.ts

@@ -2,6 +2,7 @@
  * Inference util – OpenAI client, inference() for structured output, sendAIMessage for chat.
  */
 import OpenAI from 'openai';
+import type { ResponseInput } from "openai/resources/responses/responses.js";
 import { logger } from './logger.js';
 import { prisma } from '../lib/prisma.js';
 import { chatChannel, pusher } from '../lib/pusher.js';
@@ -275,25 +276,93 @@ export async function sendAIMessage(
   };
 }
 
+/** Responses API user parts use `type: "input_*"`; chat completions use `text` / `image_url` / etc. */
+function isResponseInputWithInputParts(
+  content: OpenAI.Chat.Completions.ChatCompletionMessageParam[] | ResponseInput
+): content is ResponseInput {
+  if (!Array.isArray(content)) return false;
+  for (const msg of content) {
+    if (!msg || typeof msg !== "object" || !("content" in msg)) continue;
+    const parts = (msg as { content?: unknown }).content;
+    if (!Array.isArray(parts)) continue;
+    for (const part of parts) {
+      if (
+        part &&
+        typeof part === "object" &&
+        "type" in part &&
+        typeof (part as { type: string }).type === "string" &&
+        (part as { type: string }).type.startsWith("input_")
+      ) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+function buildResponsesParseInput(
+  content: string | OpenAI.Chat.Completions.ChatCompletionMessageParam[] | ResponseInput
+): ResponseInput {
+  if (typeof content === "string") {
+    return [{ role: "user", content: [{ type: "input_text", text: content }] }];
+  }
+  if (isResponseInputWithInputParts(content)) {
+    return content;
+  }
+  return content as unknown as ResponseInput;
+}
+
 export async function inference<T>(
-  content: string | OpenAI.Chat.Completions.ChatCompletionMessageParam[],
+  content:
+    | string
+    | OpenAI.Chat.Completions.ChatCompletionMessageParam[]
+    | ResponseInput,
   format?: ZodSchema,
   options?: InferenceOptions,
 ): Promise<T> {
-  const input = normalizeInferenceInput(content);
   const reason = getInferenceReason(options);
   const model = options?.model ?? DEFAULT_INFERENCE_MODEL;
-  const estimatedInputTokens = input.reduce(
-    (total, message) => total + estimateTokenCount(message.content),
-    0,
-  );
+  const estimatedInputTokens =
+    typeof content === 'string'
+      ? estimateTokenCount(content)
+      : isResponseInputWithInputParts(content)
+        ? estimateTokenCount(
+            content
+              .flatMap((item) =>
+                typeof (item as any)?.content === 'string'
+                  ? [(item as any).content]
+                  : Array.isArray((item as any)?.content)
+                    ? (item as any).content
+                        .filter((p: any) => p?.type === 'input_text')
+                        .map((p: any) => p?.text ?? '')
+                    : [],
+              )
+              .join('\n'),
+          )
+        : (content as OpenAI.Chat.Completions.ChatCompletionMessageParam[]).reduce(
+            (total, message) =>
+              total +
+              estimateTokenCount(
+                typeof message.content === 'string' ? message.content : '',
+              ),
+            0,
+          );
   const operation = format ? 'responses.parse' : 'chat.completions';
 
   try {
     if (!format) {
+      if (typeof content !== 'string' && isResponseInputWithInputParts(content)) {
+        throw new Error(
+          'normalizeInferenceInput cannot handle ResponseInput content with input_* parts when format is undefined; pass a format to use responses.parse.',
+        );
+      }
+
+      const messages = normalizeInferenceInput(
+        content as string | OpenAI.Chat.Completions.ChatCompletionMessageParam[],
+      );
       const completion = await openAIClient.chat.completions.create({
         model,
-        messages: input,
+        messages,
         ...(options?.temperature !== undefined
           ? { temperature: options.temperature }
           : {}),
@@ -315,6 +384,7 @@ export async function inference<T>(
       return completion.choices[0]?.message?.content as T;
     }
 
+    const input = buildResponsesParseInput(content);
     const completion = await openAIClient.responses.parse({
       model,
       input,