resync

README.md

@@ -1,5 +1,5 @@
  # ExamCooker 
-
+  
 Welcome to **ExamCooker** – a one-stop solution to all your exam problems, powered by ACM-VIT and VIT Vellore. The biggest problem to deal with in VIT is exam resources! This website solves all your issues from notes to past papers to YouTube links. It is an efficient and user-friendly website that helps you manage and save the most needed resource right before exams, **Time!**
 
 (PS: We know that you probably left everything for the last minute :D)

app/actions/update-paper-metadata.ts

@@ -33,6 +33,34 @@ const schema = z.object({
 
 export type UpdatePaperMetadataInput = z.input<typeof schema>;
 
+function isQuestionPaperLinkUniqueConstraintError(error: unknown) {
+    if (!error || typeof error !== "object") {
+        return false;
+    }
+
+    const code =
+        typeof (error as { code?: unknown }).code === "string"
+            ? (error as { code: string }).code
+            : "";
+    if (code !== "23505") {
+        return false;
+    }
+
+    const constraint =
+        typeof (error as { constraint?: unknown }).constraint === "string"
+            ? (error as { constraint: string }).constraint
+            : "";
+    const message =
+        typeof (error as { message?: unknown }).message === "string"
+            ? (error as { message: string }).message.toLowerCase()
+            : "";
+
+    return (
+        constraint === "PastPaper_questionPaperId_key" ||
+        message.includes("pastpaper_questionpaperid_key")
+    );
+}
+
 export async function updatePaperMetadata(input: UpdatePaperMetadataInput) {
     const session = await auth();
     if (session?.user?.role !== "MODERATOR") {
@@ -42,83 +70,140 @@ export async function updatePaperMetadata(input: UpdatePaperMetadataInput) {
     const parsed = schema.parse(input);
 
     let questionPaperId: string | null = null;
-
-    if (parsed.hasAnswerKey) {
-        if (!parsed.questionPaperId) {
-            throw new Error("Answer keys must be linked to a question paper.");
+    let previousQuestionPaperId: string | null = null;
+
+    try {
+        const result = await db.transaction(async (tx) => {
+            const [existingPaper] = await tx
+                .select({
+                    id: pastPaper.id,
+                    questionPaperId: pastPaper.questionPaperId,
+                })
+                .from(pastPaper)
+                .where(eq(pastPaper.id, parsed.id))
+                .limit(1);
+
+            if (!existingPaper) {
+                throw new Error("Past paper not found.");
+            }
+
+            let nextQuestionPaperId: string | null = null;
+
+            if (parsed.hasAnswerKey) {
+                if (!parsed.questionPaperId) {
+                    throw new Error("Answer keys must be linked to a question paper.");
+                }
+
+                if (parsed.questionPaperId === parsed.id) {
+                    throw new Error("A paper cannot be linked to itself.");
+                }
+
+                const [questionPaper] = await tx
+                    .select({
+                        id: pastPaper.id,
+                        title: pastPaper.title,
+                        courseId: pastPaper.courseId,
+                        hasAnswerKey: pastPaper.hasAnswerKey,
+                    })
+                    .from(pastPaper)
+                    .where(eq(pastPaper.id, parsed.questionPaperId))
+                    .limit(1);
+
+                if (!questionPaper) {
+                    throw new Error("Question paper not found.");
+                }
+
+                if (questionPaper.hasAnswerKey) {
+                    throw new Error("Question paper cannot itself be marked as an answer key.");
+                }
+
+                if (
+                    parsed.courseId !== null &&
+                    questionPaper.courseId !== null &&
+                    parsed.courseId !== questionPaper.courseId
+                ) {
+                    throw new Error("Answer key and question paper must belong to the same course.");
+                }
+
+                const [conflictingLink] = await tx
+                    .select({
+                        id: pastPaper.id,
+                        title: pastPaper.title,
+                    })
+                    .from(pastPaper)
+                    .where(
+                        and(
+                            eq(pastPaper.questionPaperId, parsed.questionPaperId),
+                            ne(pastPaper.id, parsed.id),
+                        ),
+                    )
+                    .limit(1);
+
+                if (conflictingLink) {
+                    throw new Error(
+                        `Question paper already has an answer key linked: ${conflictingLink.title}`,
+                    );
+                }
+
+                const [linkedAnswerKey] = await tx
+                    .select({
+                        id: pastPaper.id,
+                        title: pastPaper.title,
+                    })
+                    .from(pastPaper)
+                    .where(
+                        and(
+                            eq(pastPaper.questionPaperId, parsed.id),
+                            ne(pastPaper.id, parsed.id),
+                        ),
+                    )
+                    .limit(1);
+
+                if (linkedAnswerKey) {
+                    throw new Error(
+                        `This paper already has an answer key linked: ${linkedAnswerKey.title}`,
+                    );
+                }
+
+                nextQuestionPaperId = questionPaper.id;
+            }
+
+            await tx
+                .update(pastPaper)
+                .set({
+                    courseId: parsed.courseId,
+                    examType: parsed.examType,
+                    slot: parsed.slot,
+                    year: parsed.year,
+                    semester: parsed.semester,
+                    campus: parsed.campus,
+                    hasAnswerKey: parsed.hasAnswerKey,
+                    questionPaperId: nextQuestionPaperId,
+                })
+                .where(eq(pastPaper.id, parsed.id));
+
+            return {
+                questionPaperId: nextQuestionPaperId,
+                previousQuestionPaperId: existingPaper.questionPaperId,
+            };
+        });
+
+        questionPaperId = result.questionPaperId;
+        previousQuestionPaperId = result.previousQuestionPaperId;
+    } catch (error) {
+        if (isQuestionPaperLinkUniqueConstraintError(error)) {
+            throw new Error("Question paper already has an answer key linked.");
         }
 
-        if (parsed.questionPaperId === parsed.id) {
-            throw new Error("A paper cannot be linked to itself.");
-        }
-
-        const [questionPaper] = await db
-            .select({
-                id: pastPaper.id,
-                title: pastPaper.title,
-                courseId: pastPaper.courseId,
-                hasAnswerKey: pastPaper.hasAnswerKey,
-            })
-            .from(pastPaper)
-            .where(eq(pastPaper.id, parsed.questionPaperId))
-            .limit(1);
-
-        if (!questionPaper) {
-            throw new Error("Question paper not found.");
-        }
-
-        if (questionPaper.hasAnswerKey) {
-            throw new Error("Question paper cannot itself be marked as an answer key.");
-        }
-
-        if (
-            parsed.courseId !== null &&
-            questionPaper.courseId !== null &&
-            parsed.courseId !== questionPaper.courseId
-        ) {
-            throw new Error("Answer key and question paper must belong to the same course.");
-        }
-
-        const [conflictingLink] = await db
-            .select({
-                id: pastPaper.id,
-                title: pastPaper.title,
-            })
-            .from(pastPaper)
-            .where(
-                and(
-                    eq(pastPaper.questionPaperId, parsed.questionPaperId),
-                    ne(pastPaper.id, parsed.id),
-                ),
-            )
-            .limit(1);
-
-        if (conflictingLink) {
-            throw new Error(
-                `Question paper already has an answer key linked: ${conflictingLink.title}`,
-            );
-        }
-
-        questionPaperId = questionPaper.id;
+        throw error;
     }
 
-    await db
-        .update(pastPaper)
-        .set({
-            courseId: parsed.courseId,
-            examType: parsed.examType,
-            slot: parsed.slot,
-            year: parsed.year,
-            semester: parsed.semester,
-            campus: parsed.campus,
-            hasAnswerKey: parsed.hasAnswerKey,
-            questionPaperId,
-        })
-        .where(eq(pastPaper.id, parsed.id));
-
     revalidatePath("/mod/papers/review");
     revalidateTag("past_papers", "minutes");
     revalidateTag(`past_paper:${parsed.id}`, "minutes");
+    if (previousQuestionPaperId) {
+        revalidateTag(`past_paper:${previousQuestionPaperId}`, "minutes");
+    }
     if (questionPaperId) {
         revalidateTag(`past_paper:${questionPaperId}`, "minutes");
     }

app/api/pdf/markdown/route.ts

@@ -284,6 +284,14 @@ function getStreamErrorMessage(error: unknown, streamError: unknown) {
   return fallbackMessage || "Failed to convert this PDF to Markdown.";
 }
 
+function getIncompletePdfMarkdownMessage(finishReason: string | undefined) {
+  if (finishReason !== "length") {
+    return null;
+  }
+
+  return "The Markdown conversion was cut off before it finished. Try a smaller PDF or fewer edited pages.";
+}
+
 function getAiProviderFromModel(modelId: string) {
   const [provider] = modelId.split("/");
   return provider && provider !== modelId ? provider : "openai";
@@ -676,6 +684,7 @@ export async function POST(request: NextRequest) {
         const enqueue = (payload: unknown) => {
           controller.enqueue(encoder.encode(`${JSON.stringify(payload)}\n`));
         };
+        let finishReason: string | undefined;
 
         try {
           const streamedQuestions: PdfPaperQuestion[] = [];
@@ -696,6 +705,12 @@ export async function POST(request: NextRequest) {
           }
 
           const questions = await result.output;
+          finishReason = (await result.finishReason) ?? undefined;
+          const incompleteMessage = getIncompletePdfMarkdownMessage(finishReason);
+          if (incompleteMessage) {
+            throw new Error(incompleteMessage);
+          }
+
           const paper = PdfPaperDocumentSchema.parse({
             schemaVersion: "exam-questions-v1",
             questions,
@@ -731,7 +746,7 @@ export async function POST(request: NextRequest) {
             fileBytes: pdfBuffer.byteLength,
             fileName: parsedBody.fileName,
             fileUrl: fileUrl.href,
-            finishReason: result.finishReason,
+            finishReason: Promise.resolve(finishReason),
             httpStatus: 200,
             isError: false,
             latencySeconds: Math.max(Date.now() - llmStartedAt, 0) / 1000,
@@ -762,6 +777,8 @@ export async function POST(request: NextRequest) {
             fileBytes: pdfBuffer.byteLength,
             fileName: parsedBody.fileName,
             fileUrl: fileUrl.href,
+            finishReason:
+              finishReason === undefined ? result.finishReason : Promise.resolve(finishReason),
             httpStatus: request.signal.aborted ? 499 : 500,
             isError: true,
             latencySeconds: Math.max(Date.now() - llmStartedAt, 0) / 1000,

app/api/realtime/session/route.ts

@@ -1,7 +1,7 @@
 import { NextResponse, type NextRequest } from "next/server";
 import { auth } from "@/app/auth";
 
-const DEFAULT_REALTIME_MODEL = "gpt-realtime-mini";
+const DEFAULT_REALTIME_MODEL = "gpt-realtime-2";
 
 function isAbortLikeError(error: unknown) {
   return (

app/components/voice/voice-agent-provider.tsx

@@ -105,7 +105,7 @@ export default function VoiceAgentProvider({
       auth: { sessionEndpoint: "/api/realtime/session" },
       debug: VOICE_DEBUG,
       instructions: "Voice guide is preparing.",
-      model: "gpt-realtime-mini",
+      model: "gpt-realtime-2",
       maxOutputTokens: 90,
       outputMode: "audio",
       postToolResponse: true,
@@ -780,7 +780,7 @@ export default function VoiceAgentProvider({
       debug: VOICE_DEBUG,
       instructions: VOICE_GUIDE_INSTRUCTIONS,
       maxOutputTokens: 400,
-      model: "gpt-realtime-mini",
+      model: "gpt-realtime-2",
       onGenerationCompleted: (generation) => {
         const voiceSessionId = voiceAnalyticsSessionIdRef.current;
         if (!voiceSessionId) {

app/components/voice/voice-runtime.tsx

@@ -71,7 +71,7 @@ type MutableRealtimeSession<TContext = unknown> = RealtimeSession<TContext> & {
   };
 };
 
-const DEFAULT_MODEL = "gpt-realtime-mini";
+const DEFAULT_MODEL = "gpt-realtime-2";
 const DEFAULT_INSTRUCTIONS =
   "You are a voice control agent for a web app. Use registered tools whenever you can take action. Keep any spoken reply brief.";
 const TOOL_INPUT_RECOVERY_PROMPT =

lib/data/past-paper-detail.ts

@@ -88,7 +88,12 @@ const loadPastPaperDetail = cache(async (id: string) => {
         .leftJoin(course, eq(pastPaper.courseId, course.id))
         .leftJoin(pastPaperToTag, eq(pastPaperToTag.a, pastPaper.id))
         .leftJoin(tag, eq(pastPaperToTag.b, tag.id))
-        .where(eq(pastPaper.id, id))
+        .where(
+            and(
+                eq(pastPaper.id, id),
+                eq(pastPaper.isClear, true),
+            ),
+        )
         .orderBy(asc(tag.name));
 
     const firstRow = rows[0];
@@ -157,7 +162,7 @@ export async function getPastPaperDetail(id: string) {
 
     return withPastPapersSurfaceRedisCache(
         {
-            keyParts: ["past-paper-detail", { id }],
+            keyParts: ["published-past-paper-detail", { id }],
             deserialize: deserializePastPaperDetail,
         },
         async () => loadPastPaperDetail(id),
@@ -182,7 +187,7 @@ export async function getSiblingPastPaper(input: {
 
     return withPastPapersSurfaceRedisCache(
         {
-            keyParts: ["sibling-past-paper", input],
+            keyParts: ["published-sibling-past-paper", input],
         },
         async () => {
             const select = {
@@ -201,7 +206,12 @@ export async function getSiblingPastPaper(input: {
                     .select(select)
                     .from(pastPaper)
                     .leftJoin(course, eq(pastPaper.courseId, course.id))
-                    .where(eq(pastPaper.id, input.questionPaperId))
+                    .where(
+                        and(
+                            eq(pastPaper.id, input.questionPaperId),
+                            eq(pastPaper.isClear, true),
+                        ),
+                    )
                     .limit(1);
 
                 const linkedQuestionPaper = linkedQuestionPaperRows[0];