From ce9011bf351d9666bb2e81c92ae06a0eb1716d12 Mon Sep 17 00:00:00 2001 From: nsfisis Date: Wed, 31 Dec 2025 13:25:42 +0900 Subject: feat(study): render note-based cards using template system MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Update StudyPage to support both legacy cards (direct front/back) and note-based cards (template rendering with field values). Add new CardForStudy type that includes note type templates and field values as a name-value map for efficient client-side rendering. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 --- src/server/repositories/card.test.ts | 50 ++++++++++++++++ src/server/repositories/card.ts | 107 ++++++++++++++++++++++++++++++++++- src/server/repositories/types.ts | 20 +++++++ src/server/routes/cards.test.ts | 1 + src/server/routes/study.test.ts | 100 +++++++++++--------------------- src/server/routes/study.ts | 6 +- 6 files changed, 210 insertions(+), 74 deletions(-) (limited to 'src/server') diff --git a/src/server/repositories/card.test.ts b/src/server/repositories/card.test.ts index 64c071e..9d7ffa6 100644 --- a/src/server/repositories/card.test.ts +++ b/src/server/repositories/card.test.ts @@ -1,6 +1,7 @@ import { describe, expect, it, vi } from "vitest"; import type { Card, + CardForStudy, CardRepository, CardWithNoteData, Note, @@ -85,6 +86,21 @@ function createMockCardWithNoteData( }; } +function createMockCardForStudy( + overrides: Partial = {}, +): CardForStudy { + const card = createMockCard({ + noteId: overrides.noteType ? "note-uuid-123" : null, + isReversed: overrides.noteType ? false : null, + ...overrides, + }); + return { + ...card, + noteType: overrides.noteType ?? null, + fieldValuesMap: overrides.fieldValuesMap ?? {}, + }; +} + function createMockCardRepo(): CardRepository { return { findByDeckId: vi.fn(), @@ -97,6 +113,7 @@ function createMockCardRepo(): CardRepository { softDeleteByNoteId: vi.fn(), findDueCards: vi.fn(), findDueCardsWithNoteData: vi.fn(), + findDueCardsForStudy: vi.fn(), updateFSRSFields: vi.fn(), }; } @@ -354,6 +371,39 @@ describe("Card interface contracts", () => { expect(cardWithNote).toHaveProperty("fieldValues"); expect(Array.isArray(cardWithNote.fieldValues)).toBe(true); }); + + it("CardForStudy extends Card with noteType and fieldValuesMap", () => { + const cardForStudy = createMockCardForStudy({ + noteType: { + frontTemplate: "{{Front}}", + backTemplate: "{{Back}}", + }, + fieldValuesMap: { + Front: "Question", + Back: "Answer", + }, + }); + + expect(cardForStudy).toHaveProperty("id"); + expect(cardForStudy).toHaveProperty("deckId"); + expect(cardForStudy).toHaveProperty("noteType"); + expect(cardForStudy).toHaveProperty("fieldValuesMap"); + expect(cardForStudy.noteType?.frontTemplate).toBe("{{Front}}"); + expect(cardForStudy.fieldValuesMap.Front).toBe("Question"); + }); + + it("CardForStudy can represent legacy card with null noteType", () => { + const legacyCard = createMockCardForStudy({ + front: "Legacy Question", + back: "Legacy Answer", + }); + + expect(legacyCard.noteId).toBeNull(); + expect(legacyCard.noteType).toBeNull(); + expect(legacyCard.fieldValuesMap).toEqual({}); + expect(legacyCard.front).toBe("Legacy Question"); + expect(legacyCard.back).toBe("Legacy Answer"); + }); }); describe("Card and Note relationship", () => { diff --git a/src/server/repositories/card.ts b/src/server/repositories/card.ts index 92811d4..7116642 100644 --- a/src/server/repositories/card.ts +++ b/src/server/repositories/card.ts @@ -1,7 +1,19 @@ import { and, eq, isNull, lte, sql } from "drizzle-orm"; import { db } from "../db/index.js"; -import { CardState, cards, noteFieldValues, notes } from "../db/schema.js"; -import type { Card, CardRepository, CardWithNoteData } from "./types.js"; +import { + CardState, + cards, + noteFieldTypes, + noteFieldValues, + notes, + noteTypes, +} from "../db/schema.js"; +import type { + Card, + CardForStudy, + CardRepository, + CardWithNoteData, +} from "./types.js"; export const cardRepository: CardRepository = { async findByDeckId(deckId: string): Promise { @@ -219,6 +231,97 @@ export const cardRepository: CardRepository = { return cardsWithNoteData; }, + async findDueCardsForStudy( + deckId: string, + now: Date, + limit: number, + ): Promise { + const dueCards = await this.findDueCards(deckId, now, limit); + + const cardsForStudy: CardForStudy[] = []; + + for (const card of dueCards) { + // Legacy card (no note association) + if (!card.noteId) { + cardsForStudy.push({ + ...card, + noteType: null, + fieldValuesMap: {}, + }); + continue; + } + + // Fetch note to get noteTypeId + const noteResult = await db + .select() + .from(notes) + .where(and(eq(notes.id, card.noteId), isNull(notes.deletedAt))); + + const note = noteResult[0]; + if (!note) { + // Note was deleted, treat as legacy card + cardsForStudy.push({ + ...card, + noteType: null, + fieldValuesMap: {}, + }); + continue; + } + + // Fetch note type for templates + const noteTypeResult = await db + .select({ + frontTemplate: noteTypes.frontTemplate, + backTemplate: noteTypes.backTemplate, + }) + .from(noteTypes) + .where( + and(eq(noteTypes.id, note.noteTypeId), isNull(noteTypes.deletedAt)), + ); + + const noteType = noteTypeResult[0]; + if (!noteType) { + // Note type was deleted, treat as legacy card + cardsForStudy.push({ + ...card, + noteType: null, + fieldValuesMap: {}, + }); + continue; + } + + // Fetch field values with their field names + const fieldValuesWithNames = await db + .select({ + fieldName: noteFieldTypes.name, + value: noteFieldValues.value, + }) + .from(noteFieldValues) + .innerJoin( + noteFieldTypes, + eq(noteFieldValues.noteFieldTypeId, noteFieldTypes.id), + ) + .where(eq(noteFieldValues.noteId, card.noteId)); + + // Convert to name-value map + const fieldValuesMap: Record = {}; + for (const fv of fieldValuesWithNames) { + fieldValuesMap[fv.fieldName] = fv.value; + } + + cardsForStudy.push({ + ...card, + noteType: { + frontTemplate: noteType.frontTemplate, + backTemplate: noteType.backTemplate, + }, + fieldValuesMap, + }); + } + + return cardsForStudy; + }, + async updateFSRSFields( id: string, deckId: string, diff --git a/src/server/repositories/types.ts b/src/server/repositories/types.ts index 8b86061..c864be0 100644 --- a/src/server/repositories/types.ts +++ b/src/server/repositories/types.ts @@ -108,6 +108,21 @@ export interface CardWithNoteData extends Card { fieldValues: NoteFieldValue[]; } +/** + * Card data prepared for study, including all necessary template rendering info. + * For note-based cards, includes templates and field values as a name-value map. + * For legacy cards, note and templates are null. + */ +export interface CardForStudy extends Card { + /** Note type templates for rendering (null for legacy cards) */ + noteType: { + frontTemplate: string; + backTemplate: string; + } | null; + /** Field values as a name-value map for template rendering (empty for legacy cards) */ + fieldValuesMap: Record; +} + export interface CardRepository { findByDeckId(deckId: string): Promise; findById(id: string, deckId: string): Promise; @@ -139,6 +154,11 @@ export interface CardRepository { now: Date, limit: number, ): Promise; + findDueCardsForStudy( + deckId: string, + now: Date, + limit: number, + ): Promise; updateFSRSFields( id: string, deckId: string, diff --git a/src/server/routes/cards.test.ts b/src/server/routes/cards.test.ts index 53991f3..780ea44 100644 --- a/src/server/routes/cards.test.ts +++ b/src/server/routes/cards.test.ts @@ -26,6 +26,7 @@ function createMockCardRepo(): CardRepository { softDeleteByNoteId: vi.fn(), findDueCards: vi.fn(), findDueCardsWithNoteData: vi.fn(), + findDueCardsForStudy: vi.fn(), updateFSRSFields: vi.fn(), }; } diff --git a/src/server/routes/study.test.ts b/src/server/routes/study.test.ts index 77cb15c..41abecd 100644 --- a/src/server/routes/study.test.ts +++ b/src/server/routes/study.test.ts @@ -5,12 +5,10 @@ import { CardState, Rating } from "../db/schema.js"; import { errorHandler } from "../middleware/index.js"; import type { Card, + CardForStudy, CardRepository, - CardWithNoteData, Deck, DeckRepository, - Note, - NoteFieldValue, ReviewLog, ReviewLogRepository, } from "../repositories/index.js"; @@ -28,6 +26,7 @@ function createMockCardRepo(): CardRepository { softDeleteByNoteId: vi.fn(), findDueCards: vi.fn(), findDueCardsWithNoteData: vi.fn(), + findDueCardsForStudy: vi.fn(), updateFSRSFields: vi.fn(), }; } @@ -118,47 +117,19 @@ function createMockReviewLog(overrides: Partial = {}): ReviewLog { }; } -function createMockCardWithNoteData( - overrides: Partial = {}, -): CardWithNoteData { +function createMockCardForStudy( + overrides: Partial = {}, +): CardForStudy { return { ...createMockCard(overrides), - note: overrides.note ?? null, - fieldValues: overrides.fieldValues ?? [], - }; -} - -function createMockNote(overrides: Partial = {}): Note { - return { - id: "note-uuid-123", - deckId: "deck-uuid-123", - noteTypeId: "note-type-uuid-123", - createdAt: new Date("2024-01-01"), - updatedAt: new Date("2024-01-01"), - deletedAt: null, - syncVersion: 0, - ...overrides, - }; -} - -function createMockNoteFieldValue( - overrides: Partial = {}, -): NoteFieldValue { - return { - id: "field-value-uuid-123", - noteId: "note-uuid-123", - noteFieldTypeId: "field-type-uuid-123", - value: "Test value", - createdAt: new Date("2024-01-01"), - updatedAt: new Date("2024-01-01"), - syncVersion: 0, - ...overrides, + noteType: overrides.noteType ?? null, + fieldValuesMap: overrides.fieldValuesMap ?? {}, }; } interface StudyResponse { card?: Card; - cards?: CardWithNoteData[]; + cards?: CardForStudy[]; error?: { code: string; message: string; @@ -195,7 +166,7 @@ describe("GET /api/decks/:deckId/study", () => { vi.mocked(mockDeckRepo.findById).mockResolvedValue( createMockDeck({ id: DECK_ID }), ); - vi.mocked(mockCardRepo.findDueCardsWithNoteData).mockResolvedValue([]); + vi.mocked(mockCardRepo.findDueCardsForStudy).mockResolvedValue([]); const res = await app.request(`/api/decks/${DECK_ID}/study`, { method: "GET", @@ -209,36 +180,34 @@ describe("GET /api/decks/:deckId/study", () => { DECK_ID, "user-uuid-123", ); - expect(mockCardRepo.findDueCardsWithNoteData).toHaveBeenCalledWith( + expect(mockCardRepo.findDueCardsForStudy).toHaveBeenCalledWith( DECK_ID, expect.any(Date), 100, ); }); - it("returns due cards with note data", async () => { + it("returns due cards (legacy cards without note)", async () => { const mockCards = [ - createMockCardWithNoteData({ + createMockCardForStudy({ id: "card-1", front: "Q1", back: "A1", - note: null, - fieldValues: [], + noteType: null, + fieldValuesMap: {}, }), - createMockCardWithNoteData({ + createMockCardForStudy({ id: "card-2", front: "Q2", back: "A2", - note: null, - fieldValues: [], + noteType: null, + fieldValuesMap: {}, }), ]; vi.mocked(mockDeckRepo.findById).mockResolvedValue( createMockDeck({ id: DECK_ID }), ); - vi.mocked(mockCardRepo.findDueCardsWithNoteData).mockResolvedValue( - mockCards, - ); + vi.mocked(mockCardRepo.findDueCardsForStudy).mockResolvedValue(mockCards); const res = await app.request(`/api/decks/${DECK_ID}/study`, { method: "GET", @@ -248,32 +217,29 @@ describe("GET /api/decks/:deckId/study", () => { expect(res.status).toBe(200); const body = (await res.json()) as StudyResponse; expect(body.cards).toHaveLength(2); + expect(body.cards?.[0]?.noteType).toBeNull(); }); - it("returns due cards with note and field values when available", async () => { - const mockNote = createMockNote({ id: "note-1" }); - const mockFieldValues = [ - createMockNoteFieldValue({ noteId: "note-1", value: "Front" }), - createMockNoteFieldValue({ - id: "fv-2", - noteId: "note-1", - value: "Back", - }), - ]; + it("returns due cards with note type and field values when available", async () => { const mockCards = [ - createMockCardWithNoteData({ + createMockCardForStudy({ id: "card-1", noteId: "note-1", - note: mockNote, - fieldValues: mockFieldValues, + isReversed: false, + noteType: { + frontTemplate: "{{Front}}", + backTemplate: "{{Back}}", + }, + fieldValuesMap: { + Front: "Question", + Back: "Answer", + }, }), ]; vi.mocked(mockDeckRepo.findById).mockResolvedValue( createMockDeck({ id: DECK_ID }), ); - vi.mocked(mockCardRepo.findDueCardsWithNoteData).mockResolvedValue( - mockCards, - ); + vi.mocked(mockCardRepo.findDueCardsForStudy).mockResolvedValue(mockCards); const res = await app.request(`/api/decks/${DECK_ID}/study`, { method: "GET", @@ -283,8 +249,8 @@ describe("GET /api/decks/:deckId/study", () => { expect(res.status).toBe(200); const body = (await res.json()) as StudyResponse; expect(body.cards).toHaveLength(1); - expect(body.cards?.[0]?.note?.id).toBe("note-1"); - expect(body.cards?.[0]?.fieldValues).toHaveLength(2); + expect(body.cards?.[0]?.noteType?.frontTemplate).toBe("{{Front}}"); + expect(body.cards?.[0]?.fieldValuesMap?.Front).toBe("Question"); }); it("returns 404 for non-existent deck", async () => { diff --git a/src/server/routes/study.ts b/src/server/routes/study.ts index ccb0692..9c16699 100644 --- a/src/server/routes/study.ts +++ b/src/server/routes/study.ts @@ -51,11 +51,7 @@ export function createStudyRouter(deps: StudyDependencies) { } const now = new Date(); - const dueCards = await cardRepo.findDueCardsWithNoteData( - deckId, - now, - 100, - ); + const dueCards = await cardRepo.findDueCardsForStudy(deckId, now, 100); return c.json({ cards: dueCards }, 200); }) -- cgit v1.2.3-70-g09d2