question-bank-framework 0.6.0 → 0.7.1

package/framework/lib/quiz-storage.ts

@@ -1,140 +1,150 @@
-// Quiz persistence: Convex when VITE_CONVEX_URL is set, localStorage fallback.
-// Namespaced per bank via `namespace` so multiple banks can coexist.
+// Quiz persistence. localStorage is always the working copy; when the bank
+// sets `sync`, every change is also pushed to the server and the two are
+// reconciled (newest `updatedAt` wins, deletions are tombstoned server-side).
 // Framework-owned: eject with `qb reveal framework/lib/quiz-storage.ts`.
 
-import { ConvexHttpClient } from 'convex/browser';
-import { convexApi } from './convex-api.ts';
 import type { QuizSession } from '../../core/types.ts';
-
-const convexUrl = import.meta.env?.VITE_CONVEX_URL || (import.meta.env?.CONVEX_URL as string | undefined);
-const convexClient = convexUrl ? new ConvexHttpClient(convexUrl) : null;
-
-type QuizDocument = QuizSession & { _id: string; _creationTime: number };
+import { readLocal, syncEnabled, syncRequest, writeLocal, type StorageTarget } from './sync-client.ts';
 
 const keyFor = (namespace: string) => `${namespace}-question-bank-quizzes`;
+const pendingDeletesKeyFor = (namespace: string) => `${namespace}-question-bank-quiz-deletes`;
 
-const readLocalQuizzes = (namespace: string): QuizSession[] => {
-  if (typeof window === 'undefined') return [];
-  try {
-    const value: unknown = JSON.parse(window.localStorage.getItem(keyFor(namespace)) ?? '[]');
-    return Array.isArray(value) ? (value as QuizSession[]) : [];
-  } catch {
-    return [];
-  }
-};
+const isQuizList = (value: unknown): value is QuizSession[] => Array.isArray(value);
+const isStringList = (value: unknown): value is string[] =>
+  Array.isArray(value) && value.every((item) => typeof item === 'string');
 
-const writeLocalQuizzes = (namespace: string, quizzes: QuizSession[]) => {
-  if (typeof window !== 'undefined') window.localStorage.setItem(keyFor(namespace), JSON.stringify(quizzes));
-};
+const readLocalQuizzes = (namespace: string): QuizSession[] => readLocal(keyFor(namespace), [], isQuizList);
+const writeLocalQuizzes = (namespace: string, quizzes: QuizSession[]) => writeLocal(keyFor(namespace), sortQuizzes(quizzes));
+const readPendingDeletes = (namespace: string): string[] => readLocal(pendingDeletesKeyFor(namespace), [], isStringList);
+const writePendingDeletes = (namespace: string, ids: string[]) => writeLocal(pendingDeletesKeyFor(namespace), ids);
 
-export function saveQuizLocally(namespace: string, session: QuizSession): void {
+const versionOf = (quiz: QuizSession): number => quiz.updatedAt ?? quiz.createdAt;
+const sortQuizzes = (quizzes: QuizSession[]) => [...quizzes].sort((a, b) => b.createdAt - a.createdAt);
+
+function upsertLocal(namespace: string, session: QuizSession): void {
   writeLocalQuizzes(namespace, [session, ...readLocalQuizzes(namespace).filter((quiz) => quiz.id !== session.id)]);
 }
 
-export async function deleteQuiz(namespace: string, id: string): Promise<void> {
-  if (convexClient && !id.startsWith('local_')) {
-    await convexClient.mutation(convexApi.quizzes.remove, { quizId: id });
+function removeLocal(namespace: string, id: string): void {
+  writeLocalQuizzes(namespace, readLocalQuizzes(namespace).filter((quiz) => quiz.id !== id));
+}
+
+/** Push one quiz. The server keeps the newer copy and returns what it stored (410 when deleted). */
+async function pushQuiz(target: StorageTarget, session: QuizSession): Promise<void> {
+  if (!syncEnabled(target)) return;
+  const { status, data } = await syncRequest<QuizSession>(target, `/quizzes/${encodeURIComponent(session.id)}`, {
+    method: 'PUT',
+    body: { ...session, updatedAt: versionOf(session) },
+  });
+  if (status === 410) {
+    removeLocal(target.namespace, session.id);
+    return;
+  }
+  const local = readLocalQuizzes(target.namespace).find((quiz) => quiz.id === session.id);
+  if (!local || versionOf(data) > versionOf(local)) upsertLocal(target.namespace, data);
+}
+
+/**
+ * Two-way merge: retry pending deletes, adopt newer server copies, drop
+ * server-deleted quizzes, and upload local quizzes the server lacks or has
+ * an older copy of. Falls back to the local list when the server is unreachable.
+ */
+async function reconcile(target: StorageTarget): Promise<QuizSession[]> {
+  const namespace = target.namespace;
+  if (!syncEnabled(target)) return sortQuizzes(readLocalQuizzes(namespace));
+  try {
+    const pending = readPendingDeletes(namespace);
+    for (const id of pending) {
+      await syncRequest(target, `/quizzes/${encodeURIComponent(id)}`, { method: 'DELETE' });
+    }
+    if (pending.length > 0) writePendingDeletes(namespace, []);
+
+    const { data } = await syncRequest<{ quizzes: QuizSession[]; deleted: string[] }>(target, '/quizzes');
+    const deleted = new Set(data.deleted);
+    const remote = new Map(data.quizzes.map((quiz) => [quiz.id, quiz]));
+    const merged = new Map<string, QuizSession>(remote);
+    const uploads: QuizSession[] = [];
+    for (const local of readLocalQuizzes(namespace)) {
+      if (deleted.has(local.id)) continue;
+      const server = remote.get(local.id);
+      if (!server || versionOf(local) > versionOf(server)) {
+        merged.set(local.id, local);
+        uploads.push(local);
+      }
+    }
+    writeLocalQuizzes(namespace, [...merged.values()]);
+    await Promise.all(uploads.map((quiz) => pushQuiz(target, quiz)));
+    return sortQuizzes(readLocalQuizzes(namespace));
+  } catch {
+    return sortQuizzes(readLocalQuizzes(namespace));
   }
-  writeLocalQuizzes(
-    namespace,
-    readLocalQuizzes(namespace).filter((quiz) => quiz.id !== id),
-  );
 }
 
-const fromDocument = (document: QuizDocument): QuizSession => ({
-  id: document._id,
-  title: document.title,
-  questionIds: document.questionIds,
-  answers: document.answers,
-  currentQuestion: document.currentQuestion,
-  completed: document.completed,
-  createdAt: document.createdAt ?? document._creationTime,
-});
-
-export async function createQuiz(namespace: string, title: string, questionIds: string[]): Promise<QuizSession> {
-  const localSession: QuizSession = {
-    id: `local_${crypto.randomUUID()}`,
+export async function createQuiz(target: StorageTarget, title: string, questionIds: string[]): Promise<QuizSession> {
+  const now = Date.now();
+  const session: QuizSession = {
+    id: crypto.randomUUID(),
     title,
     questionIds,
     answers: {},
     currentQuestion: 0,
     completed: false,
-    createdAt: Date.now(),
+    createdAt: now,
+    updatedAt: now,
   };
+  upsertLocal(target.namespace, session);
+  await pushQuiz(target, session).catch(() => {
+    // Stays local; the next reconcile uploads it.
+  });
+  return session;
+}
 
-  if (convexClient) {
-    try {
-      const id = await convexClient.mutation(convexApi.quizzes.create, { title, questionIds });
-      return { ...localSession, id };
-    } catch {
-      writeLocalQuizzes(namespace, [localSession, ...readLocalQuizzes(namespace)]);
-      return localSession;
-    }
-  }
+export async function getQuiz(target: StorageTarget, id: string): Promise<QuizSession | null> {
+  const quizzes = await reconcile(target);
+  return quizzes.find((quiz) => quiz.id === id) ?? null;
+}
+
+export async function listQuizzes(target: StorageTarget): Promise<QuizSession[]> {
+  return reconcile(target);
+}
+
+/** Record a change locally (stamps `updatedAt`). Call `syncQuiz` afterwards to push it. */
+export function saveQuizLocally(target: StorageTarget, session: QuizSession): QuizSession {
+  const updated = { ...session, updatedAt: Math.max(Date.now(), versionOf(session) + 1) };
+  upsertLocal(target.namespace, updated);
+  return updated;
+}
 
-  writeLocalQuizzes(namespace, [localSession, ...readLocalQuizzes(namespace)]);
-  return localSession;
+/** Push a locally saved quiz. A failed push stays local; the next reconcile uploads it. */
+export async function syncQuiz(target: StorageTarget, session: QuizSession): Promise<void> {
+  await pushQuiz(target, session).catch(() => {});
 }
 
-export async function getQuiz(namespace: string, id: string): Promise<QuizSession | null> {
-  const localSession = readLocalQuizzes(namespace).find((quiz) => quiz.id === id);
-  if (id.startsWith('local_') || !convexClient) return localSession ?? null;
+/** saveQuizLocally + syncQuiz. */
+export async function saveQuiz(target: StorageTarget, session: QuizSession): Promise<QuizSession> {
+  const updated = saveQuizLocally(target, session);
+  await syncQuiz(target, updated);
+  return updated;
+}
+
+export async function deleteQuiz(target: StorageTarget, id: string): Promise<void> {
+  removeLocal(target.namespace, id);
+  if (!syncEnabled(target)) return;
   try {
-    const document = await convexClient.query(convexApi.quizzes.get, { quizId: id });
-    return document ? fromDocument(document) : (localSession ?? null);
+    await syncRequest(target, `/quizzes/${encodeURIComponent(id)}`, { method: 'DELETE' });
   } catch {
-    return localSession ?? null;
+    writePendingDeletes(target.namespace, [...new Set([...readPendingDeletes(target.namespace), id])]);
   }
 }
 
-export async function saveQuizProgress(
-  namespace: string,
-  session: QuizSession,
-  progress: Pick<QuizSession, 'title' | 'answers' | 'currentQuestion' | 'completed'>,
-): Promise<void> {
-  const updated = { ...session, ...progress };
-  saveQuizLocally(namespace, updated);
-  if (!convexClient || updated.id.startsWith('local_')) return;
-  await convexClient.mutation(convexApi.quizzes.saveProgress, {
-    quizId: updated.id,
-    title: updated.title,
-    answers: updated.answers,
-    currentQuestion: updated.currentQuestion,
-    completed: updated.completed,
-  });
-}
-
 // Replaces a quiz's question list (reorder / remove / append). Answers for
 // removed questions are dropped and the current position is kept on the same
 // question where possible.
-export async function setQuizQuestions(namespace: string, session: QuizSession, questionIds: string[]): Promise<QuizSession> {
+export async function setQuizQuestions(target: StorageTarget, session: QuizSession, questionIds: string[]): Promise<QuizSession> {
   const kept = new Set(questionIds);
   const answers = Object.fromEntries(Object.entries(session.answers).filter(([id]) => kept.has(id)));
   const currentId = session.questionIds[session.currentQuestion];
   const currentIndex = currentId === undefined ? -1 : questionIds.indexOf(currentId);
   const currentQuestion = currentIndex >= 0 ? currentIndex : Math.min(session.currentQuestion, Math.max(questionIds.length - 1, 0));
-  const updated: QuizSession = { ...session, questionIds, answers, currentQuestion };
-  if (convexClient && !updated.id.startsWith('local_')) {
-    await convexClient.mutation(convexApi.quizzes.setQuestions, {
-      quizId: updated.id,
-      questionIds,
-      answers,
-      currentQuestion,
-    });
-  }
-  saveQuizLocally(namespace, updated);
-  return updated;
-}
-
-export async function listQuizzes(namespace: string): Promise<QuizSession[]> {
-  const localQuizzes = readLocalQuizzes(namespace);
-  if (!convexClient) return localQuizzes;
-  try {
-    const documents = await convexClient.query(convexApi.quizzes.list, {});
-    const remoteQuizzes = documents.map(fromDocument);
-    const ids = new Set(remoteQuizzes.map((quiz) => quiz.id));
-    return [...remoteQuizzes, ...localQuizzes.filter((quiz) => !ids.has(quiz.id))];
-  } catch {
-    return localQuizzes;
-  }
+  return saveQuiz(target, { ...session, questionIds, answers, currentQuestion });
 }

package/framework/lib/sync-client.ts

@@ -0,0 +1,45 @@
+// HTTP client for the framework's sync API (see framework/cloudflare/).
+// Framework-owned: eject with `qb reveal framework/lib/sync-client.ts`.
+
+import type { Bank } from '../../core/types.ts';
+
+/** What the storage modules need from a bank: its namespace and optional sync endpoint. */
+export type StorageTarget = Pick<Bank, 'namespace' | 'sync'>;
+
+export function syncEnabled(target: StorageTarget): boolean {
+  return typeof window !== 'undefined' && !!target.sync?.url;
+}
+
+/** JSON request against `<sync.url>/<namespace><path>`. Throws on network or HTTP errors. */
+export async function syncRequest<T>(
+  target: StorageTarget,
+  path: string,
+  init?: { method?: 'GET' | 'PUT' | 'DELETE'; body?: unknown },
+): Promise<{ status: number; data: T }> {
+  if (!target.sync?.url) throw new Error('Sync is not configured for this bank.');
+  const base = target.sync.url.replace(/\/+$/, '');
+  const response = await fetch(`${base}/${encodeURIComponent(target.namespace)}${path}`, {
+    method: init?.method ?? 'GET',
+    headers: init?.body === undefined ? undefined : { 'content-type': 'application/json' },
+    body: init?.body === undefined ? undefined : JSON.stringify(init.body),
+    credentials: 'same-origin',
+  });
+  if (!response.ok && response.status !== 410) {
+    throw new Error(`Sync request failed: ${response.status} ${response.statusText}`);
+  }
+  return { status: response.status, data: (await response.json()) as T };
+}
+
+export function readLocal<T>(key: string, fallback: T, valid: (value: unknown) => value is T): T {
+  if (typeof window === 'undefined') return fallback;
+  try {
+    const value: unknown = JSON.parse(window.localStorage.getItem(key) ?? 'null');
+    return valid(value) ? value : fallback;
+  } catch {
+    return fallback;
+  }
+}
+
+export function writeLocal(key: string, value: unknown): void {
+  if (typeof window !== 'undefined') window.localStorage.setItem(key, JSON.stringify(value));
+}

package/framework/styles/theme.css

@@ -7,6 +7,10 @@
  *   @import 'question-bank-framework/framework/styles/theme.css';
  */
 
+/* KaTeX CSS from the framework's own katex, matching the version that renders
+ * math in MarkdownContent. Don't import katex CSS separately in your app. */
+@import 'katex/dist/katex.min.css';
+
 @theme inline {
   --font-sans: 'DM Sans', ui-sans-serif, system-ui, sans-serif;
   --font-display: 'Fraunces', Georgia, serif;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "question-bank-framework",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "description": "Framework-style question bank: TanStack Start + TanStack Table grid, quizzes, and filter DSL. Bring your own bank.config.ts + content/. Eject any framework/ file with `qb reveal` (Vike-style).",
   "type": "module",
   "license": "MIT",
@@ -13,6 +13,7 @@
     "./core": "./core/index.ts",
     "./framework": "./framework/index.ts",
     "./framework/*": "./framework/*",
+    "./cloudflare": "./framework/cloudflare/index.ts",
     "./template/*": "./template/*"
   },
   "bin": {
@@ -35,12 +36,10 @@
     "@tanstack/react-virtual": "^3.14.19",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
-    "convex": "^1.46.0",
     "katex": "^0.19.0",
     "lucide-react": "^1.57.0",
     "radix-ui": "^1.8.1",
     "react-markdown": "^10.1.0",
-    "rehype-katex": "^7.0.1",
     "remark-gfm": "^4.0.1",
     "remark-math": "^6.0.0",
     "tailwind-merge": "^3.7.0",

package/template/bank.config.ts

@@ -25,6 +25,8 @@ export const bank = defineBank({
     description: 'A searchable, section-classified question bank built from COMP20008 past exams.',
   },
   namespace: 'comp20008',
+  // Sync quizzes + statuses to the Durable Object served by src/server.ts.
+  sync: { url: '/api/qb' },
   fields: [
     {
       id: 'year',

package/template/src/routes/styles.css

@@ -1,5 +1,4 @@
 @import url('https://fonts.googleapis.com/css2?family=DM+Mono:wght@400;500&family=DM+Sans:wght@400;500;600;700;800&family=Fraunces:opsz,wght@9..144,600;9..144,700&display=swap');
-@import 'katex/dist/katex.min.css';
 @import 'tailwindcss';
 @import 'tw-animate-css';
 @import 'question-bank-framework/framework/styles/theme.css';

package/template/src/server.ts

@@ -0,0 +1,17 @@
+// Worker entry: serves the question bank sync API under /api/qb (matching
+// `sync: { url: '/api/qb' }` in bank.config.ts) and everything else through
+// TanStack Start.
+//
+// Before deploying publicly, gate the API: pass `authorize` (e.g. verify a
+// Cloudflare Access JWT) or put the whole Worker behind Cloudflare Access.
+
+import handler from '@tanstack/react-start/server-entry';
+import { handleQuestionBankRequest } from 'question-bank-framework/cloudflare';
+
+export { QuestionBankStore } from 'question-bank-framework/cloudflare';
+
+export default {
+  async fetch(request: Request, env: object) {
+    return (await handleQuestionBankRequest(request, env)) ?? handler.fetch(request);
+  },
+};

package/template/vite.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'vite';
+import { cloudflare } from '@cloudflare/vite-plugin';
+import { tanstackStart } from '@tanstack/react-start/plugin/vite';
+import viteReact from '@vitejs/plugin-react';
+import tailwindcss from '@tailwindcss/vite';
+
+export default defineConfig({
+  resolve: { tsconfigPaths: true },
+  plugins: [cloudflare({ viteEnvironment: { name: 'ssr' } }), tailwindcss(), tanstackStart(), viteReact()],
+});

package/template/wrangler.jsonc

@@ -0,0 +1,16 @@
+// Cloudflare Workers config. `pnpm dev` runs this locally in workerd (via
+// @cloudflare/vite-plugin) and persists the sync store to .wrangler/state;
+// `pnpm build && wrangler deploy` publishes it. Rename "name" for your bank.
+{
+  "$schema": "node_modules/wrangler/config-schema.json",
+  "name": "question-bank",
+  "compatibility_date": "2026-11-14",
+  "compatibility_flags": ["nodejs_compat"],
+  "main": "src/server.ts",
+  "observability": { "enabled": true },
+  // Quizzes + question statuses: one SQLite-backed Durable Object per bank namespace.
+  "durable_objects": {
+    "bindings": [{ "name": "QB_STORE", "class_name": "QuestionBankStore" }]
+  },
+  "migrations": [{ "tag": "v1", "new_sqlite_classes": ["QuestionBankStore"] }]
+}

package/framework/convex/questionStatuses.ts

@@ -1,30 +0,0 @@
-import { mutationGeneric as mutation, queryGeneric as query } from 'convex/server'
-import { v } from 'convex/values'
-
-const statusValidator = v.union(v.literal('unanswered'), v.literal('revisit'), v.literal('complete'))
-
-export const list = query({
-  args: {},
-  handler: async (ctx) => await ctx.db.query('questionStatuses').collect(),
-})
-
-export const set = mutation({
-  args: {
-    questionId: v.string(),
-    status: statusValidator,
-  },
-  handler: async (ctx, { questionId, status }) => {
-    const existing = await ctx.db.query('questionStatuses')
-      .withIndex('by_question_id', (q) => q.eq('questionId', questionId))
-      .first()
-    const updatedAt = Date.now()
-
-    if (existing) {
-      await ctx.db.patch(existing._id, { status, updatedAt })
-    } else {
-      await ctx.db.insert('questionStatuses', { questionId, status, updatedAt })
-    }
-
-    return updatedAt
-  },
-})

package/framework/convex/quizzes.ts

@@ -1,62 +0,0 @@
-import { mutationGeneric as mutation, queryGeneric as query } from 'convex/server'
-import { v } from 'convex/values'
-
-export const create = mutation({
-  args: {
-    title: v.string(),
-    questionIds: v.array(v.string()),
-  },
-  handler: async (ctx, { title, questionIds }) => {
-    const createdAt = Date.now()
-    return await ctx.db.insert('quizzes', {
-      title,
-      questionIds,
-      answers: {},
-      currentQuestion: 0,
-      completed: false,
-      createdAt,
-    })
-  },
-})
-
-export const get = query({
-  args: { quizId: v.id('quizzes') },
-  handler: async (ctx, { quizId }) => await ctx.db.get(quizId),
-})
-
-export const list = query({
-  args: {},
-  handler: async (ctx) => await ctx.db.query('quizzes').withIndex('by_created_at').order('desc').collect(),
-})
-
-export const remove = mutation({
-  args: { quizId: v.id('quizzes') },
-  handler: async (ctx, { quizId }) => {
-    await ctx.db.delete(quizId)
-  },
-})
-
-export const saveProgress = mutation({
-  args: {
-    quizId: v.id('quizzes'),
-    title: v.string(),
-    answers: v.record(v.string(), v.union(v.string(), v.array(v.string()), v.record(v.string(), v.string()))),
-    currentQuestion: v.number(),
-    completed: v.boolean(),
-  },
-  handler: async (ctx, { quizId, title, answers, currentQuestion, completed }) => {
-    await ctx.db.patch(quizId, { title, answers, currentQuestion, completed })
-  },
-})
-
-export const setQuestions = mutation({
-  args: {
-    quizId: v.id('quizzes'),
-    questionIds: v.array(v.string()),
-    answers: v.record(v.string(), v.union(v.string(), v.array(v.string()), v.record(v.string(), v.string()))),
-    currentQuestion: v.number(),
-  },
-  handler: async (ctx, { quizId, questionIds, answers, currentQuestion }) => {
-    await ctx.db.patch(quizId, { questionIds, answers, currentQuestion })
-  },
-})

package/framework/convex/schema.ts

@@ -1,18 +0,0 @@
-import { defineSchema, defineTable } from 'convex/server'
-import { v } from 'convex/values'
-
-export default defineSchema({
-  quizzes: defineTable({
-    title: v.string(),
-    questionIds: v.array(v.string()),
-    answers: v.record(v.string(), v.union(v.string(), v.array(v.string()), v.record(v.string(), v.string()))),
-    currentQuestion: v.number(),
-    completed: v.boolean(),
-    createdAt: v.number(),
-  }).index('by_created_at', ['createdAt']),
-  questionStatuses: defineTable({
-    questionId: v.string(),
-    status: v.union(v.literal('unanswered'), v.literal('revisit'), v.literal('complete')),
-    updatedAt: v.number(),
-  }).index('by_question_id', ['questionId']),
-})

package/framework/lib/convex-api.ts

@@ -1,43 +0,0 @@
-// Typed Convex function references. No value imports — safe to eject.
-// Framework-owned: eject with `qb reveal framework/lib/convex-api.ts`.
-
-import { makeFunctionReference } from 'convex/server';
-import type { QuestionStatus, QuizAnswer, QuizSession } from '../../core/types.ts';
-
-type CreateQuizArgs = { title: string; questionIds: string[] };
-type ProgressArgs = {
-  quizId: string;
-  title: string;
-  answers: Record<string, QuizAnswer>;
-  currentQuestion: number;
-  completed: boolean;
-};
-type SetQuestionsArgs = {
-  quizId: string;
-  questionIds: string[];
-  answers: Record<string, QuizAnswer>;
-  currentQuestion: number;
-};
-type QuizDocument = QuizSession & { _id: string; _creationTime: number };
-type QuestionStatusDocument = {
-  _id: string;
-  _creationTime: number;
-  questionId: string;
-  status: QuestionStatus;
-  updatedAt: number;
-};
-
-export const convexApi = {
-  quizzes: {
-    create: makeFunctionReference<'mutation', CreateQuizArgs, string>('quizzes:create'),
-    get: makeFunctionReference<'query', { quizId: string }, QuizDocument | null>('quizzes:get'),
-    list: makeFunctionReference<'query', Record<string, never>, QuizDocument[]>('quizzes:list'),
-    remove: makeFunctionReference<'mutation', { quizId: string }, null>('quizzes:remove'),
-    saveProgress: makeFunctionReference<'mutation', ProgressArgs, null>('quizzes:saveProgress'),
-    setQuestions: makeFunctionReference<'mutation', SetQuestionsArgs, null>('quizzes:setQuestions'),
-  },
-  questionStatuses: {
-    list: makeFunctionReference<'query', Record<string, never>, QuestionStatusDocument[]>('questionStatuses:list'),
-    set: makeFunctionReference<'mutation', { questionId: string; status: QuestionStatus }, number>('questionStatuses:set'),
-  },
-};