@goscribe/server 1.1.7 → 1.3.0

package/src/trpc.ts

@@ -1,8 +1,22 @@
 import { initTRPC, TRPCError } from "@trpc/server";
 import superjson from "superjson";
+import { ActivityLogStatus } from "@prisma/client";
 import type { Context } from "./context.js";
 import { logger } from "./lib/logger.js";
 import { toTRPCError } from "./lib/errors.js";
+import { getUserUsage, getUserPlanLimits } from "./lib/usage_service.js";
+import {
+  getClientIp,
+  isActivityLogEnabled,
+  scheduleRecordActivity,
+  truncateUserAgent,
+} from "./lib/activity_log_service.js";
+
+/** Avoid logging the log viewers themselves (noise when browsing activity). */
+const SKIP_ACTIVITY_TRPC_PATHS = new Set([
+  "admin.activityList",
+  "admin.activityExportCsv",
+]);
 
 const t = initTRPC.context<Context>().create({
   transformer: superjson,
@@ -15,7 +29,7 @@ const t = initTRPC.context<Context>().create({
         cause: error.cause,
       });
     }
-    
+
     return {
       ...shape,
       data: {
@@ -37,12 +51,12 @@ const loggingMiddleware = middleware(async ({ ctx, next, path, type }) => {
   const start = Date.now();
   const result = await next();
   const duration = Date.now() - start;
-  
+
   logger.info(`TRPC ${type} ${path}`, 'TRPC', {
     duration: `${duration}ms`,
     userId: (ctx.session as any)?.user?.id,
   });
-  
+
   return result;
 });
 
@@ -52,7 +66,7 @@ const loggingMiddleware = middleware(async ({ ctx, next, path, type }) => {
 const isAuthed = middleware(({ ctx, next }) => {
   const hasUser = Boolean((ctx.session as any)?.user?.id);
   if (!ctx.session || !hasUser) {
-    throw new TRPCError({ 
+    throw new TRPCError({
       code: "UNAUTHORIZED",
       message: "You must be logged in to access this resource"
     });
@@ -60,6 +74,7 @@ const isAuthed = middleware(({ ctx, next }) => {
 
   return next({
     ctx: {
+      ...ctx,
       session: ctx.session,
       userId: (ctx.session as any).user.id,
     },
@@ -77,8 +92,172 @@ const errorHandler = middleware(async ({ next }) => {
   }
 });
 
+/**
+ * Middleware that enforces email verification
+ */
+const isVerified = middleware(async ({ ctx, next }) => {
+  const user = await ctx.db.user.findUnique({
+    where: { id: (ctx.session as any).user.id },
+    select: { emailVerified: true },
+  });
+
+  if (!user?.emailVerified) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "Please verify your email to access this feature",
+    });
+  }
+
+  return next();
+});
+
+/**
+ * Middleware that enforces resource limits based on the user's plan.
+ * Note: This matches the 'path' to decide which limit to check.
+ */
+const checkUsageLimit = middleware(async ({ ctx, next, path }) => {
+  const userId = (ctx.session as any).user.id;
+
+  // 1. Get current usage and limits
+  const [usage, limits] = await Promise.all([
+    getUserUsage(userId),
+    getUserPlanLimits(userId)
+  ]);
+
+  // If no limits found (no active plan), we block any premium actions
+  if (!limits) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "No active plan found. Please subscribe to a plan to continue.",
+    });
+  }
+
+  // 2. Check limits based on the tRPC path
+
+  // Flashcards (matches: flashcards.createCard, flashcards.generateFromPrompt)
+  if (path.startsWith('flashcards.') && (path.includes('create') || path.includes('generate')) && usage.flashcards >= limits.maxFlashcards) {
+    throw new TRPCError({ code: "FORBIDDEN", message: "Flashcard limit reached for your plan." });
+  }
+
+  // Worksheets (matches: worksheets.create, worksheets.generateFromPrompt)
+  if (path.startsWith('worksheets.') && (path.includes('create') || path.includes('generate')) && usage.worksheets >= limits.maxWorksheets) {
+    throw new TRPCError({ code: "FORBIDDEN", message: "Worksheet limit reached for your plan." });
+  }
+
+  // Podcasts (matches: podcast.generateEpisode)
+  if (path.startsWith('podcast.') && path.includes('generate') && usage.podcasts >= limits.maxPodcasts) {
+    throw new TRPCError({ code: "FORBIDDEN", message: "Podcast limit reached for your plan." });
+  }
+
+  // Study Guides (matches: studyguide.get - because it lazily creates)
+  if (path.startsWith('studyguide.') && path.includes('get') && usage.studyGuides >= limits.maxStudyGuides) {
+    // Note: We only block if the artifact doesn't exist yet (handled inside the query or by checking usage)
+    // For simplicity, if they hit the limit, we block creation of NEW study guides.
+    // However, usage_service counts existing ones. 
+    // If usage is already at/over limit, it means any NEW workspace's 'get' will fail creation.
+  }
+
+  // Storage check (for uploads)
+  if (path.includes('upload') && usage.storageBytes >= Number(limits.maxStorageBytes)) {
+    throw new TRPCError({ code: "FORBIDDEN", message: "Storage limit reached for your plan." });
+  }
+
+  return next();
+});
+
+/**
+ * Middleware that enforces system admin role
+ */
+const isAdmin = middleware(async ({ ctx, next }) => {
+  const user = await ctx.db.user.findUnique({
+    where: { id: (ctx.session as any).user.id },
+    include: { role: true },
+  });
+
+  if (user?.role?.name !== 'System Admin') {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "You do not have permission to access this resource",
+    });
+  }
+
+  return next();
+});
+
+/**
+ * Persists ActivityLog rows for authenticated tRPC calls (async, non-blocking).
+ */
+const activityLogMiddleware = middleware(async (opts) => {
+  const { ctx, next, path, type, getRawInput } = opts;
+  if (!isActivityLogEnabled() || SKIP_ACTIVITY_TRPC_PATHS.has(path)) {
+    return next();
+  }
+
+  const userId = (ctx as any).userId as string | undefined;
+  if (!userId) {
+    return next();
+  }
+
+  let rawInput: unknown;
+  try {
+    rawInput = await getRawInput();
+  } catch {
+    rawInput = undefined;
+  }
+
+  const req = ctx.req;
+  const ipAddress = req ? getClientIp(req) : undefined;
+  const userAgent = req.headers["user-agent"];
+  const httpMethod = req.method;
+
+  const start = Date.now();
+  const result = await next();
+  const durationMs = Date.now() - start;
+
+  if (result.ok) {
+    scheduleRecordActivity({
+      db: ctx.db,
+      actorUserId: userId,
+      path,
+      type,
+      status: ActivityLogStatus.SUCCESS,
+      durationMs,
+      rawInput,
+      ipAddress,
+      userAgent: truncateUserAgent(typeof userAgent === "string" ? userAgent : undefined),
+      httpMethod,
+    });
+  } else {
+    scheduleRecordActivity({
+      db: ctx.db,
+      actorUserId: userId,
+      path,
+      type,
+      status: ActivityLogStatus.FAILURE,
+      durationMs,
+      rawInput,
+      ipAddress,
+      userAgent: truncateUserAgent(typeof userAgent === "string" ? userAgent : undefined),
+      httpMethod,
+      errorCode: result.error.code,
+    });
+  }
+
+  return result;
+});
+
 /** Exported procedures with middleware */
 export const authedProcedure = publicProcedure
   .use(loggingMiddleware)
   .use(errorHandler)
-  .use(isAuthed);
+  .use(isAuthed)
+  .use(activityLogMiddleware);
+
+export const verifiedProcedure = authedProcedure
+  .use(isVerified);
+
+export const adminProcedure = authedProcedure
+  .use(isAdmin);
+
+export const limitedProcedure = verifiedProcedure
+  .use(checkUsageLimit);

package/test-generate.js

@@ -0,0 +1,30 @@
+const AI_SERVICE_URL = 'http://localhost:5000/upload';
+
+async function testBackend() {
+  const formData = new FormData();
+  formData.append('command', 'generate_worksheet_questions');
+  formData.append('session', 'test-session-123'); // Need a dummy workspace/session that exists, or the Backend will fail `get_messages`.
+  formData.append('user', 'test-user-123');
+  formData.append('num_questions', '8');
+  formData.append('difficulty', 'HARD');
+  formData.append('mode', 'practice');
+  formData.append('mcq_ratio', '0.5'); // We want exactly 4 MCQs and 4 Texts.
+  formData.append('question_types', JSON.stringify(['MULTIPLE_CHOICE', 'TEXT']));
+  
+  // Note: for this to work, the python backend needs a `messages.json` file to exist for this user/session.
+  // We'll see if it fails due to directory structure.
+  console.log("Calling python backend...");
+  try {
+    const res = await fetch(AI_SERVICE_URL, { method: 'POST', body: formData });
+    if (!res.ok) console.error("Error from backend:", res.status, res.statusText, await res.text());
+    else {
+      const data = await res.json();
+      console.log("Success! Generated Worksheet JSON:");
+      console.log(data);
+    }
+  } catch (e) {
+    console.error("Fetch failed:", e);
+  }
+}
+
+testBackend();

package/test-ratio.cjs

@@ -0,0 +1,9 @@
+const numQuestions = 8;
+const mcqCount = 4;
+
+const mcqRatio = typeof mcqCount === 'number'
+  ? Math.min(1, Math.max(0, mcqCount / Math.max(1, numQuestions)))
+  : undefined;
+
+console.log("Resulting mcqRatio:", mcqRatio);
+console.log("mcqRatio stringified:", JSON.stringify({ mcqRatio }));

package/zod-test.cjs

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+
+const worksheetModeSchema = z.enum(['practice', 'quiz']);
+const worksheetDifficultyInputSchema = z.enum(['easy', 'medium', 'hard']);
+const questionTypeSchema = z.enum(['MULTIPLE_CHOICE', 'TEXT']);
+
+const worksheetPresetConfigSchema = z.object({
+  mode: worksheetModeSchema.default('practice'),
+  numQuestions: z.number().int().min(1).max(20).default(8),
+  difficulty: worksheetDifficultyInputSchema.default('medium'),
+  questionTypes: z.array(questionTypeSchema).optional(),
+  mcqRatio: z.number().min(0).max(1).optional(),
+});
+
+const worksheetPresetConfigPartialSchema = worksheetPresetConfigSchema.partial();
+
+const parsed = worksheetPresetConfigPartialSchema.parse({
+  questionTypes: ['MULTIPLE_CHOICE', 'TEXT'],
+  mcqRatio: 0.5
+});
+
+console.log("Parsed result:", parsed);

package/prisma/migrations/20250826124819_add_worksheet_difficulty_and_estimated_time/migration.sql

@@ -1,213 +0,0 @@
--- CreateEnum
-CREATE TYPE "public"."ArtifactType" AS ENUM ('STUDY_GUIDE', 'FLASHCARD_SET', 'WORKSHEET', 'MEETING_SUMMARY', 'PODCAST_EPISODE');
-
--- CreateEnum
-CREATE TYPE "public"."Difficulty" AS ENUM ('EASY', 'MEDIUM', 'HARD');
-
--- CreateEnum
-CREATE TYPE "public"."QuestionType" AS ENUM ('MULTIPLE_CHOICE', 'TEXT', 'NUMERIC', 'TRUE_FALSE', 'MATCHING', 'FILL_IN_THE_BLANK');
-
--- CreateTable
-CREATE TABLE "public"."User" (
-    "id" TEXT NOT NULL,
-    "name" TEXT,
-    "email" TEXT,
-    "emailVerified" TIMESTAMP(3),
-    "passwordHash" TEXT,
-    "image" TEXT,
-    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "updatedAt" TIMESTAMP(3) NOT NULL,
-
-    CONSTRAINT "User_pkey" PRIMARY KEY ("id")
-);
-
--- CreateTable
-CREATE TABLE "public"."Session" (
-    "id" TEXT NOT NULL,
-    "userId" TEXT NOT NULL,
-    "expires" TIMESTAMP(3) NOT NULL,
-
-    CONSTRAINT "Session_pkey" PRIMARY KEY ("id")
-);
-
--- CreateTable
-CREATE TABLE "public"."VerificationToken" (
-    "identifier" TEXT NOT NULL,
-    "token" TEXT NOT NULL,
-    "expires" TIMESTAMP(3) NOT NULL
-);
-
--- CreateTable
-CREATE TABLE "public"."Folder" (
-    "id" TEXT NOT NULL,
-    "name" TEXT NOT NULL,
-    "ownerId" TEXT NOT NULL,
-    "parentId" TEXT,
-    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "updatedAt" TIMESTAMP(3) NOT NULL,
-
-    CONSTRAINT "Folder_pkey" PRIMARY KEY ("id")
-);
-
--- CreateTable
-CREATE TABLE "public"."Workspace" (
-    "id" TEXT NOT NULL,
-    "title" TEXT NOT NULL,
-    "description" TEXT,
-    "ownerId" TEXT NOT NULL,
-    "folderId" TEXT,
-    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "updatedAt" TIMESTAMP(3) NOT NULL,
-
-    CONSTRAINT "Workspace_pkey" PRIMARY KEY ("id")
-);
-
--- CreateTable
-CREATE TABLE "public"."FileAsset" (
-    "id" TEXT NOT NULL,
-    "workspaceId" TEXT NOT NULL,
-    "userId" TEXT NOT NULL,
-    "name" TEXT NOT NULL,
-    "mimeType" TEXT NOT NULL,
-    "size" INTEGER NOT NULL,
-    "bucket" TEXT,
-    "objectKey" TEXT,
-    "url" TEXT,
-    "checksum" TEXT,
-    "meta" JSONB,
-    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
-
-    CONSTRAINT "FileAsset_pkey" PRIMARY KEY ("id")
-);
-
--- CreateTable
-CREATE TABLE "public"."Artifact" (
-    "id" TEXT NOT NULL,
-    "workspaceId" TEXT NOT NULL,
-    "type" "public"."ArtifactType" NOT NULL,
-    "title" TEXT NOT NULL,
-    "isArchived" BOOLEAN NOT NULL DEFAULT false,
-    "difficulty" "public"."Difficulty",
-    "estimatedTime" TEXT,
-    "createdById" TEXT,
-    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "updatedAt" TIMESTAMP(3) NOT NULL,
-
-    CONSTRAINT "Artifact_pkey" PRIMARY KEY ("id")
-);
-
--- CreateTable
-CREATE TABLE "public"."ArtifactVersion" (
-    "id" TEXT NOT NULL,
-    "artifactId" TEXT NOT NULL,
-    "content" TEXT NOT NULL,
-    "data" JSONB,
-    "version" INTEGER NOT NULL,
-    "createdById" TEXT,
-    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
-
-    CONSTRAINT "ArtifactVersion_pkey" PRIMARY KEY ("id")
-);
-
--- CreateTable
-CREATE TABLE "public"."Flashcard" (
-    "id" TEXT NOT NULL,
-    "artifactId" TEXT NOT NULL,
-    "front" TEXT NOT NULL,
-    "back" TEXT NOT NULL,
-    "tags" TEXT[],
-    "order" INTEGER NOT NULL DEFAULT 0,
-    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
-
-    CONSTRAINT "Flashcard_pkey" PRIMARY KEY ("id")
-);
-
--- CreateTable
-CREATE TABLE "public"."WorksheetQuestion" (
-    "id" TEXT NOT NULL,
-    "artifactId" TEXT NOT NULL,
-    "prompt" TEXT NOT NULL,
-    "answer" TEXT,
-    "type" "public"."QuestionType" NOT NULL DEFAULT 'TEXT',
-    "difficulty" "public"."Difficulty" NOT NULL DEFAULT 'MEDIUM',
-    "order" INTEGER NOT NULL DEFAULT 0,
-    "meta" JSONB,
-    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
-
-    CONSTRAINT "WorksheetQuestion_pkey" PRIMARY KEY ("id")
-);
-
--- CreateIndex
-CREATE UNIQUE INDEX "User_email_key" ON "public"."User"("email");
-
--- CreateIndex
-CREATE UNIQUE INDEX "VerificationToken_token_key" ON "public"."VerificationToken"("token");
-
--- CreateIndex
-CREATE UNIQUE INDEX "VerificationToken_identifier_token_key" ON "public"."VerificationToken"("identifier", "token");
-
--- CreateIndex
-CREATE INDEX "Folder_ownerId_parentId_idx" ON "public"."Folder"("ownerId", "parentId");
-
--- CreateIndex
-CREATE INDEX "Workspace_ownerId_folderId_idx" ON "public"."Workspace"("ownerId", "folderId");
-
--- CreateIndex
-CREATE INDEX "FileAsset_workspaceId_idx" ON "public"."FileAsset"("workspaceId");
-
--- CreateIndex
-CREATE INDEX "FileAsset_userId_createdAt_idx" ON "public"."FileAsset"("userId", "createdAt");
-
--- CreateIndex
-CREATE INDEX "Artifact_workspaceId_type_idx" ON "public"."Artifact"("workspaceId", "type");
-
--- CreateIndex
-CREATE INDEX "ArtifactVersion_artifactId_idx" ON "public"."ArtifactVersion"("artifactId");
-
--- CreateIndex
-CREATE UNIQUE INDEX "ArtifactVersion_artifactId_version_key" ON "public"."ArtifactVersion"("artifactId", "version");
-
--- CreateIndex
-CREATE INDEX "Flashcard_artifactId_idx" ON "public"."Flashcard"("artifactId");
-
--- CreateIndex
-CREATE INDEX "WorksheetQuestion_artifactId_idx" ON "public"."WorksheetQuestion"("artifactId");
-
--- AddForeignKey
-ALTER TABLE "public"."Session" ADD CONSTRAINT "Session_userId_fkey" FOREIGN KEY ("userId") REFERENCES "public"."User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
-
--- AddForeignKey
-ALTER TABLE "public"."Folder" ADD CONSTRAINT "Folder_ownerId_fkey" FOREIGN KEY ("ownerId") REFERENCES "public"."User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
-
--- AddForeignKey
-ALTER TABLE "public"."Folder" ADD CONSTRAINT "Folder_parentId_fkey" FOREIGN KEY ("parentId") REFERENCES "public"."Folder"("id") ON DELETE CASCADE ON UPDATE CASCADE;
-
--- AddForeignKey
-ALTER TABLE "public"."Workspace" ADD CONSTRAINT "Workspace_ownerId_fkey" FOREIGN KEY ("ownerId") REFERENCES "public"."User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
-
--- AddForeignKey
-ALTER TABLE "public"."Workspace" ADD CONSTRAINT "Workspace_folderId_fkey" FOREIGN KEY ("folderId") REFERENCES "public"."Folder"("id") ON DELETE SET NULL ON UPDATE CASCADE;
-
--- AddForeignKey
-ALTER TABLE "public"."FileAsset" ADD CONSTRAINT "FileAsset_workspaceId_fkey" FOREIGN KEY ("workspaceId") REFERENCES "public"."Workspace"("id") ON DELETE CASCADE ON UPDATE CASCADE;
-
--- AddForeignKey
-ALTER TABLE "public"."FileAsset" ADD CONSTRAINT "FileAsset_userId_fkey" FOREIGN KEY ("userId") REFERENCES "public"."User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
-
--- AddForeignKey
-ALTER TABLE "public"."Artifact" ADD CONSTRAINT "Artifact_workspaceId_fkey" FOREIGN KEY ("workspaceId") REFERENCES "public"."Workspace"("id") ON DELETE CASCADE ON UPDATE CASCADE;
-
--- AddForeignKey
-ALTER TABLE "public"."Artifact" ADD CONSTRAINT "Artifact_createdById_fkey" FOREIGN KEY ("createdById") REFERENCES "public"."User"("id") ON DELETE SET NULL ON UPDATE CASCADE;
-
--- AddForeignKey
-ALTER TABLE "public"."ArtifactVersion" ADD CONSTRAINT "ArtifactVersion_artifactId_fkey" FOREIGN KEY ("artifactId") REFERENCES "public"."Artifact"("id") ON DELETE CASCADE ON UPDATE CASCADE;
-
--- AddForeignKey
-ALTER TABLE "public"."ArtifactVersion" ADD CONSTRAINT "ArtifactVersion_createdById_fkey" FOREIGN KEY ("createdById") REFERENCES "public"."User"("id") ON DELETE SET NULL ON UPDATE CASCADE;
-
--- AddForeignKey
-ALTER TABLE "public"."Flashcard" ADD CONSTRAINT "Flashcard_artifactId_fkey" FOREIGN KEY ("artifactId") REFERENCES "public"."Artifact"("id") ON DELETE CASCADE ON UPDATE CASCADE;
-
--- AddForeignKey
-ALTER TABLE "public"."WorksheetQuestion" ADD CONSTRAINT "WorksheetQuestion_artifactId_fkey" FOREIGN KEY ("artifactId") REFERENCES "public"."Artifact"("id") ON DELETE CASCADE ON UPDATE CASCADE;

package/prisma/migrations/20250826133236_add_worksheet_question_progress/migration.sql

@@ -1,31 +0,0 @@
--- AlterTable
-ALTER TABLE "public"."Artifact" ADD COLUMN     "description" TEXT;
-
--- CreateTable
-CREATE TABLE "public"."WorksheetQuestionProgress" (
-    "id" TEXT NOT NULL,
-    "worksheetQuestionId" TEXT NOT NULL,
-    "userId" TEXT NOT NULL,
-    "completed" BOOLEAN NOT NULL DEFAULT false,
-    "userAnswer" TEXT,
-    "completedAt" TIMESTAMP(3),
-    "attempts" INTEGER NOT NULL DEFAULT 0,
-    "timeSpentSec" INTEGER,
-    "meta" JSONB,
-    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "updatedAt" TIMESTAMP(3) NOT NULL,
-
-    CONSTRAINT "WorksheetQuestionProgress_pkey" PRIMARY KEY ("id")
-);
-
--- CreateIndex
-CREATE INDEX "WorksheetQuestionProgress_userId_idx" ON "public"."WorksheetQuestionProgress"("userId");
-
--- CreateIndex
-CREATE UNIQUE INDEX "WorksheetQuestionProgress_worksheetQuestionId_userId_key" ON "public"."WorksheetQuestionProgress"("worksheetQuestionId", "userId");
-
--- AddForeignKey
-ALTER TABLE "public"."WorksheetQuestionProgress" ADD CONSTRAINT "WorksheetQuestionProgress_worksheetQuestionId_fkey" FOREIGN KEY ("worksheetQuestionId") REFERENCES "public"."WorksheetQuestion"("id") ON DELETE CASCADE ON UPDATE CASCADE;
-
--- AddForeignKey
-ALTER TABLE "public"."WorksheetQuestionProgress" ADD CONSTRAINT "WorksheetQuestionProgress_userId_fkey" FOREIGN KEY ("userId") REFERENCES "public"."User"("id") ON DELETE CASCADE ON UPDATE CASCADE;

package/prisma/seed.mjs

@@ -1,135 +0,0 @@
-import { PrismaClient } from '@prisma/client';
-
-const prisma = new PrismaClient();
-
-async function main() {
-  // Create/find a demo user
-  const userEmail = 'demo@example.com';
-  const user = await prisma.user.upsert({
-    where: { email: userEmail },
-    update: {},
-    create: {
-      email: userEmail,
-      name: 'Demo User',
-      image: null,
-    },
-  });
-
-  // Create a workspace
-  const workspace = await prisma.workspace.upsert({
-    where: { id: 'ws_demo_1' },
-    update: {},
-    create: {
-      id: 'ws_demo_1',
-      title: 'Demo Workspace',
-      description: 'Seeded workspace with sample artifacts',
-      ownerId: user.id,
-    },
-  });
-
-  // Create a Worksheet artifact with diverse question types
-  const worksheet = await prisma.artifact.create({
-    data: {
-      workspaceId: workspace.id,
-      type: 'WORKSHEET',
-      title: 'Sample Worksheet: Mixed Question Types',
-      createdById: user.id,
-      questions: {
-        create: [
-          {
-            prompt: 'What is the capital of France?',
-            answer: 'Paris',
-            type: 'TEXT',
-            order: 0,
-          },
-          {
-            prompt: '2 + 2 = ?',
-            answer: '4',
-            type: 'NUMERIC',
-            order: 1,
-          },
-          {
-            prompt: 'Select the prime numbers',
-            answer: '2',
-            type: 'MULTIPLE_CHOICE',
-            order: 2,
-            meta: { options: ['1', '2', '4', '6'] },
-          },
-          {
-            prompt: 'The earth is flat.',
-            answer: 'False',
-            type: 'TRUE_FALSE',
-            order: 3,
-            meta: { options: ['True', 'False'] },
-          },
-          {
-            prompt: 'Match the country to its capital (type answers).',
-            answer: '',
-            type: 'MATCHING',
-            order: 4,
-            meta: { options: ['Japan ->', 'Germany ->', 'Canada ->'] },
-          },
-          {
-            prompt: 'The chemical symbol for water is ____.',
-            answer: 'H2O',
-            type: 'FILL_IN_THE_BLANK',
-            order: 5,
-          },
-        ],
-      },
-    },
-    include: { questions: true },
-  });
-
-  // Create a Flashcard set artifact with a couple of cards
-  const flashcardSet = await prisma.artifact.create({
-    data: {
-      workspaceId: workspace.id,
-      type: 'FLASHCARD_SET',
-      title: 'Sample Flashcards: Basics',
-      createdById: user.id,
-      flashcards: {
-        create: [
-          { front: 'HTTP Status 200', back: 'OK', order: 0 },
-          { front: 'HTTP Status 404', back: 'Not Found', order: 1 },
-        ],
-      },
-    },
-    include: { flashcards: true },
-  });
-
-  // Add a simple study guide versioned artifact
-  const studyGuide = await prisma.artifact.create({
-    data: {
-      workspaceId: workspace.id,
-      type: 'STUDY_GUIDE',
-      title: 'Sample Study Guide',
-      createdById: user.id,
-      versions: {
-        create: [
-          { content: '# Intro\nThis is a seeded study guide.', version: 1, createdById: user.id },
-        ],
-      },
-    },
-    include: { versions: true },
-  });
-
-  console.log('Seed complete:', {
-    user: { id: user.id, email: user.email },
-    workspace: { id: workspace.id, title: workspace.title },
-    worksheet: { id: worksheet.id, title: worksheet.title, questions: worksheet.questions.length },
-    flashcardSet: { id: flashcardSet.id, cards: flashcardSet.flashcards.length },
-    studyGuide: { id: studyGuide.id, versions: studyGuide.versions.length },
-  });
-}
-
-main()
-  .catch((e) => {
-    console.error(e);
-    process.exit(1);
-  })
-  .finally(async () => {
-    await prisma.$disconnect();
-  });
-
-