feat(quiz): add Redis cache for quiz questions

- Create types/quiz.ts with shared quiz domain types
- Add getOrCreateQuestionsCache() to cache questions per quiz/locale
- Integrate cache into getQuizQuestions() with DB fallback

Author: LesiaUKR

frontend/db/queries/quiz.ts

@@ -2,6 +2,9 @@ import { and, desc, eq, inArray, sql } from 'drizzle-orm';
 import { unstable_cache } from 'next/cache';
 import { cache } from 'react';
 
+import { getOrCreateQuestionsCache } from '@/lib/quiz/quiz-answers-redis';
+import type { QuizQuestionWithAnswers } from '@/types/quiz';
+
 import { db } from '../index';
 import { categories, categoryTranslations } from '../schema/categories';
 import {
@@ -14,6 +17,7 @@ import {
   quizTranslations,
   quizzes,
 } from '../schema/quiz';
+export type { QuizAnswer, QuizQuestion, QuizQuestionWithAnswers } from '@/types/quiz';
 
 export interface Quiz {
   id: string;
@@ -27,24 +31,6 @@ export interface Quiz {
   categoryName: string | null;
 }
 
-export interface QuizQuestion {
-  id: string;
-  displayOrder: number;
-  difficulty: string | null;
-  questionText: string | null;
-  explanation: any;
-}
-
-export interface QuizAnswer {
-  id: string;
-  displayOrder: number;
-  isCorrect: boolean;
-  answerText: string | null;
-}
-
-export interface QuizQuestionWithAnswers extends QuizQuestion {
-  answers: QuizAnswer[];
-}
 
 export interface QuizAnswerClient {
   id: string;
@@ -194,6 +180,10 @@ export async function getQuizQuestions(
   quizId: string,
   locale: string = 'uk'
 ): Promise<QuizQuestionWithAnswers[]> {
+  const cached = await getOrCreateQuestionsCache(quizId, locale);
+  if (cached !== null) {
+    return cached;
+  }
   const questionsData = await db
     .select({
       id: quizQuestions.id,

frontend/lib/quiz/quiz-answers-redis.ts

@@ -1,16 +1,33 @@
-import { and, eq } from 'drizzle-orm';
+import { and, eq,inArray  } from 'drizzle-orm';
 
 import { db } from '@/db';
-import { quizAnswers, quizQuestions } from '@/db/schema/quiz';
+import { 
+  quizAnswers, 
+  quizAnswerTranslations,
+  quizQuestionContent,
+  quizQuestions} from '@/db/schema/quiz';
 import { getRedisClient } from '@/lib/redis';
+import type { QuizQuestionWithAnswers } from '@/types/quiz';
 
 interface QuizAnswersCache {
   quizId: string;
   answers: Record<string, string>;
   cachedAt: number;
 }
 
-function getCacheKey(quizId: string): string {
+interface QuizQuestionsCache {
+  quizId: string;
+  locale: string;
+  questions: QuizQuestionWithAnswers[];
+  cachedAt: number;
+}
+
+function getQuestionsCacheKey(quizId: string, locale: string): string {
+  return `quiz:questions:${quizId}:${locale}`;
+}
+
+
+function getAnswersCacheKey(quizId: string): string {
   return `quiz:answers:${quizId}`;
 }
 
@@ -23,7 +40,7 @@ export async function getOrCreateQuizAnswersCache(
     return true;
   }
 
-  const key = getCacheKey(quizId);
+  const key = getAnswersCacheKey(quizId);
 
   const existing = await redis.get<QuizAnswersCache>(key);
   if (existing) {
@@ -67,7 +84,7 @@ export async function getCorrectAnswer(
   const redis = getRedisClient();
 
   if (redis) {
-    const key = getCacheKey(quizId);
+    const key = getAnswersCacheKey(quizId);
     const cache = await redis.get<QuizAnswersCache>(key);
     if (cache) {
       return cache.answers[questionId] ?? null;
@@ -89,3 +106,93 @@ export async function getCorrectAnswer(
 
   return result[0]?.answerId ?? null;
 }
+
+export async function getOrCreateQuestionsCache(
+  quizId: string,
+  locale: string
+): Promise<QuizQuestionWithAnswers[] | null> {
+  const redis = getRedisClient();
+  if (!redis) {
+    return null;
+  }
+
+  const key = getQuestionsCacheKey(quizId, locale);
+
+  const existing = await redis.get<QuizQuestionsCache>(key);
+  if (existing) {
+    return existing.questions;
+  }
+
+  const questionsData = await db
+    .select({
+      id: quizQuestions.id,
+      displayOrder: quizQuestions.displayOrder,
+      difficulty: quizQuestions.difficulty,
+      questionText: quizQuestionContent.questionText,
+      explanation: quizQuestionContent.explanation,
+    })
+    .from(quizQuestions)
+    .leftJoin(
+      quizQuestionContent,
+      and(
+        eq(quizQuestionContent.quizQuestionId, quizQuestions.id),
+        eq(quizQuestionContent.locale, locale)
+      )
+    )
+    .where(eq(quizQuestions.quizId, quizId))
+    .orderBy(quizQuestions.displayOrder);
+
+  if (questionsData.length === 0) {
+    return [];
+  }
+
+  const questionIds = questionsData.map(q => q.id);
+
+  const allAnswers = await db
+    .select({
+      id: quizAnswers.id,
+      questionId: quizAnswers.quizQuestionId,
+      displayOrder: quizAnswers.displayOrder,
+      isCorrect: quizAnswers.isCorrect,
+      answerText: quizAnswerTranslations.answerText,
+    })
+    .from(quizAnswers)
+    .leftJoin(
+      quizAnswerTranslations,
+      and(
+        eq(quizAnswerTranslations.quizAnswerId, quizAnswers.id),
+        eq(quizAnswerTranslations.locale, locale)
+      )
+    )
+    .where(inArray(quizAnswers.quizQuestionId, questionIds))
+    .orderBy(quizAnswers.displayOrder);
+
+  const answersByQuestion = new Map<string, typeof allAnswers>();
+  for (const answer of allAnswers) {
+    const arr = answersByQuestion.get(answer.questionId) || [];
+    arr.push(answer);
+    answersByQuestion.set(answer.questionId, arr);
+  }
+
+
+  const questions: QuizQuestionWithAnswers[] = questionsData.map(q => ({
+    ...q,
+    answers: (answersByQuestion.get(q.id) || []).map(a => ({
+      id: a.id,
+      displayOrder: a.displayOrder,
+      isCorrect: a.isCorrect,
+      answerText: a.answerText,
+    })),
+  }));
+
+  const cacheData: QuizQuestionsCache = {
+    quizId,
+    locale,
+    questions,
+    cachedAt: Date.now(),
+  };
+
+  await redis.set(key, cacheData);
+
+  return questions;
+}

frontend/types/quiz.ts

@@ -0,0 +1,18 @@
+export interface QuizQuestion {
+  id: string;
+  displayOrder: number;
+  difficulty: string | null;
+  questionText: string | null;
+  explanation: any;
+}
+
+export interface QuizAnswer {
+  id: string;
+  displayOrder: number;
+  isCorrect: boolean;
+  answerText: string | null;
+}
+
+export interface QuizQuestionWithAnswers extends QuizQuestion {
+  answers: QuizAnswer[];
+}