@goscribe/server 1.0.7 → 1.0.8

package/dist/routers/flashcards.js

@@ -11,7 +11,7 @@ const ArtifactType = {
 };
 export const flashcards = router({
     listSets: authedProcedure
-        .input(z.object({ workspaceId: z.string().uuid() }))
+        .input(z.object({ workspaceId: z.string() }))
         .query(async ({ ctx, input }) => {
         const workspace = await ctx.db.workspace.findFirst({
             where: { id: input.workspaceId, ownerId: ctx.session.user.id },
@@ -20,44 +20,32 @@ export const flashcards = router({
             throw new TRPCError({ code: 'NOT_FOUND' });
         return ctx.db.artifact.findMany({
             where: { workspaceId: input.workspaceId, type: ArtifactType.FLASHCARD_SET },
-            orderBy: { updatedAt: 'desc' },
-        });
-    }),
-    createSet: authedProcedure
-        .input(z.object({ workspaceId: z.string().uuid(), title: z.string().min(1).max(120) }))
-        .mutation(async ({ ctx, input }) => {
-        const workspace = await ctx.db.workspace.findFirst({
-            where: { id: input.workspaceId, ownerId: ctx.session.user.id },
-        });
-        if (!workspace)
-            throw new TRPCError({ code: 'NOT_FOUND' });
-        return ctx.db.artifact.create({
-            data: {
-                workspaceId: input.workspaceId,
-                type: ArtifactType.FLASHCARD_SET,
-                title: input.title,
-                createdById: ctx.session.user.id,
+            include: {
+                versions: {
+                    orderBy: { version: 'desc' },
+                    take: 1, // Get only the latest version
+                },
             },
+            orderBy: { updatedAt: 'desc' },
         });
     }),
-    getSet: authedProcedure
-        .input(z.object({ setId: z.string().uuid() }))
+    listCards: authedProcedure
+        .input(z.object({ workspaceId: z.string() }))
         .query(async ({ ctx, input }) => {
         const set = await ctx.db.artifact.findFirst({
-            where: {
-                id: input.setId,
-                type: ArtifactType.FLASHCARD_SET,
-                workspace: { ownerId: ctx.session.user.id },
+            where: { workspaceId: input.workspaceId, type: ArtifactType.FLASHCARD_SET, workspace: { ownerId: ctx.session.user.id } },
+            include: {
+                flashcards: true,
             },
-            include: { flashcards: true },
+            orderBy: { updatedAt: 'desc' },
         });
         if (!set)
             throw new TRPCError({ code: 'NOT_FOUND' });
-        return set;
+        return set.flashcards;
     }),
     createCard: authedProcedure
         .input(z.object({
-        setId: z.string().uuid(),
+        workspaceId: z.string(),
         front: z.string().min(1),
         back: z.string().min(1),
         tags: z.array(z.string()).optional(),
@@ -65,13 +53,19 @@ export const flashcards = router({
     }))
         .mutation(async ({ ctx, input }) => {
         const set = await ctx.db.artifact.findFirst({
-            where: { id: input.setId, type: ArtifactType.FLASHCARD_SET, workspace: { ownerId: ctx.session.user.id } },
+            where: { type: ArtifactType.FLASHCARD_SET, workspace: {
+                    id: input.workspaceId,
+                } },
+            include: {
+                flashcards: true,
+            },
+            orderBy: { updatedAt: 'desc' },
         });
         if (!set)
             throw new TRPCError({ code: 'NOT_FOUND' });
         return ctx.db.flashcard.create({
             data: {
-                artifactId: input.setId,
+                artifactId: set.id,
                 front: input.front,
                 back: input.back,
                 tags: input.tags ?? [],
@@ -81,7 +75,7 @@ export const flashcards = router({
     }),
     updateCard: authedProcedure
         .input(z.object({
-        cardId: z.string().uuid(),
+        cardId: z.string(),
         front: z.string().optional(),
         back: z.string().optional(),
         tags: z.array(z.string()).optional(),
@@ -104,7 +98,7 @@ export const flashcards = router({
         });
     }),
     deleteCard: authedProcedure
-        .input(z.object({ cardId: z.string().uuid() }))
+        .input(z.object({ cardId: z.string() }))
         .mutation(async ({ ctx, input }) => {
         const card = await ctx.db.flashcard.findFirst({
             where: { id: input.cardId, artifact: { workspace: { ownerId: ctx.session.user.id } } },
@@ -114,14 +108,4 @@ export const flashcards = router({
         await ctx.db.flashcard.delete({ where: { id: input.cardId } });
         return true;
     }),
-    deleteSet: authedProcedure
-        .input(z.object({ setId: z.string().uuid() }))
-        .mutation(async ({ ctx, input }) => {
-        const deleted = await ctx.db.artifact.deleteMany({
-            where: { id: input.setId, type: ArtifactType.FLASHCARD_SET, workspace: { ownerId: ctx.session.user.id } },
-        });
-        if (deleted.count === 0)
-            throw new TRPCError({ code: 'NOT_FOUND' });
-        return true;
-    }),
 });

package/dist/routers/worksheets.d.ts

@@ -4,17 +4,37 @@ export declare const worksheets: import("@trpc/server").TRPCBuiltRouter<{
         session: any;
         req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
         res: import("express").Response<any, Record<string, any>>;
-        cookies: any;
+        cookies: Record<string, string | undefined>;
     };
     meta: object;
     errorShape: import("@trpc/server").TRPCDefaultErrorShape;
     transformer: true;
 }, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
-    listSets: import("@trpc/server").TRPCQueryProcedure<{
+    list: import("@trpc/server").TRPCQueryProcedure<{
         input: {
             workspaceId: string;
         };
-        output: {
+        output: ({
+            versions: {
+                id: string;
+                createdAt: Date;
+                createdById: string | null;
+                artifactId: string;
+                content: string;
+                data: import("@prisma/client/runtime/library").JsonValue | null;
+                version: number;
+            }[];
+            questions: {
+                meta: import("@prisma/client/runtime/library").JsonValue | null;
+                id: string;
+                createdAt: Date;
+                artifactId: string;
+                order: number;
+                prompt: string;
+                answer: string | null;
+                difficulty: import("@prisma/client").$Enums.Difficulty;
+            }[];
+        } & {
             id: string;
             createdAt: Date;
             updatedAt: Date;
@@ -23,10 +43,10 @@ export declare const worksheets: import("@trpc/server").TRPCBuiltRouter<{
             type: import("@prisma/client").$Enums.ArtifactType;
             isArchived: boolean;
             createdById: string | null;
-        }[];
+        })[];
         meta: object;
     }>;
-    createSet: import("@trpc/server").TRPCMutationProcedure<{
+    createWorksheet: import("@trpc/server").TRPCMutationProcedure<{
         input: {
             workspaceId: string;
             title: string;
@@ -43,9 +63,9 @@ export declare const worksheets: import("@trpc/server").TRPCBuiltRouter<{
         };
         meta: object;
     }>;
-    getSet: import("@trpc/server").TRPCQueryProcedure<{
+    get: import("@trpc/server").TRPCQueryProcedure<{
         input: {
-            setId: string;
+            worksheetId: string;
         };
         output: {
             questions: {
@@ -70,9 +90,9 @@ export declare const worksheets: import("@trpc/server").TRPCBuiltRouter<{
         };
         meta: object;
     }>;
-    createQuestion: import("@trpc/server").TRPCMutationProcedure<{
+    createWorksheetQuestion: import("@trpc/server").TRPCMutationProcedure<{
         input: {
-            setId: string;
+            worksheetId: string;
             prompt: string;
             answer?: string | undefined;
             difficulty?: "EASY" | "MEDIUM" | "HARD" | undefined;
@@ -91,9 +111,9 @@ export declare const worksheets: import("@trpc/server").TRPCBuiltRouter<{
         };
         meta: object;
     }>;
-    updateQuestion: import("@trpc/server").TRPCMutationProcedure<{
+    updateWorksheetQuestion: import("@trpc/server").TRPCMutationProcedure<{
         input: {
-            questionId: string;
+            worksheetQuestionId: string;
             prompt?: string | undefined;
             answer?: string | undefined;
             difficulty?: "EASY" | "MEDIUM" | "HARD" | undefined;
@@ -112,16 +132,16 @@ export declare const worksheets: import("@trpc/server").TRPCBuiltRouter<{
         };
         meta: object;
     }>;
-    deleteQuestion: import("@trpc/server").TRPCMutationProcedure<{
+    deleteWorksheetQuestion: import("@trpc/server").TRPCMutationProcedure<{
         input: {
-            questionId: string;
+            worksheetQuestionId: string;
         };
         output: boolean;
         meta: object;
     }>;
-    deleteSet: import("@trpc/server").TRPCMutationProcedure<{
+    deleteWorksheet: import("@trpc/server").TRPCMutationProcedure<{
         input: {
-            setId: string;
+            worksheetId: string;
         };
         output: boolean;
         meta: object;

package/dist/routers/worksheets.js

@@ -12,22 +12,27 @@ const Difficulty = {
 };
 export const worksheets = router({
     // List all worksheet artifacts for a workspace
-    listSets: authedProcedure
-        .input(z.object({ workspaceId: z.string().uuid() }))
+    list: authedProcedure
+        .input(z.object({ workspaceId: z.string() }))
         .query(async ({ ctx, input }) => {
-        const workspace = await ctx.db.workspace.findFirst({
-            where: { id: input.workspaceId, ownerId: ctx.session.user.id },
-        });
-        if (!workspace)
-            throw new TRPCError({ code: 'NOT_FOUND' });
-        return ctx.db.artifact.findMany({
+        const worksheets = await ctx.db.artifact.findMany({
             where: { workspaceId: input.workspaceId, type: ArtifactType.WORKSHEET },
+            include: {
+                versions: {
+                    orderBy: { version: 'desc' },
+                    take: 1, // Get only the latest version
+                },
+                questions: true,
+            },
             orderBy: { updatedAt: 'desc' },
         });
+        if (!worksheets)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        return worksheets;
     }),
     // Create a worksheet set
-    createSet: authedProcedure
-        .input(z.object({ workspaceId: z.string().uuid(), title: z.string().min(1).max(120) }))
+    createWorksheet: authedProcedure
+        .input(z.object({ workspaceId: z.string(), title: z.string().min(1).max(120) }))
         .mutation(async ({ ctx, input }) => {
         const workspace = await ctx.db.workspace.findFirst({
             where: { id: input.workspaceId, ownerId: ctx.session.user.id },
@@ -44,25 +49,25 @@ export const worksheets = router({
         });
     }),
     // Get a worksheet with its questions
-    getSet: authedProcedure
-        .input(z.object({ setId: z.string().uuid() }))
+    get: authedProcedure
+        .input(z.object({ worksheetId: z.string() }))
         .query(async ({ ctx, input }) => {
-        const set = await ctx.db.artifact.findFirst({
+        const worksheet = await ctx.db.artifact.findFirst({
             where: {
-                id: input.setId,
+                id: input.worksheetId,
                 type: ArtifactType.WORKSHEET,
                 workspace: { ownerId: ctx.session.user.id },
             },
             include: { questions: true },
         });
-        if (!set)
+        if (!worksheet)
             throw new TRPCError({ code: 'NOT_FOUND' });
-        return set;
+        return worksheet;
     }),
     // Add a question to a worksheet
-    createQuestion: authedProcedure
+    createWorksheetQuestion: authedProcedure
         .input(z.object({
-        setId: z.string().uuid(),
+        worksheetId: z.string(),
         prompt: z.string().min(1),
         answer: z.string().optional(),
         difficulty: z.enum(['EASY', 'MEDIUM', 'HARD']).optional(),
@@ -70,14 +75,14 @@ export const worksheets = router({
         meta: z.record(z.string(), z.unknown()).optional(),
     }))
         .mutation(async ({ ctx, input }) => {
-        const set = await ctx.db.artifact.findFirst({
-            where: { id: input.setId, type: ArtifactType.WORKSHEET, workspace: { ownerId: ctx.session.user.id } },
+        const worksheet = await ctx.db.artifact.findFirst({
+            where: { id: input.worksheetId, type: ArtifactType.WORKSHEET, workspace: { ownerId: ctx.session.user.id } },
         });
-        if (!set)
+        if (!worksheet)
             throw new TRPCError({ code: 'NOT_FOUND' });
         return ctx.db.worksheetQuestion.create({
             data: {
-                artifactId: input.setId,
+                artifactId: input.worksheetId,
                 prompt: input.prompt,
                 answer: input.answer,
                 difficulty: (input.difficulty ?? Difficulty.MEDIUM),
@@ -87,9 +92,9 @@ export const worksheets = router({
         });
     }),
     // Update a question
-    updateQuestion: authedProcedure
+    updateWorksheetQuestion: authedProcedure
         .input(z.object({
-        questionId: z.string().uuid(),
+        worksheetQuestionId: z.string(),
         prompt: z.string().optional(),
         answer: z.string().optional(),
         difficulty: z.enum(['EASY', 'MEDIUM', 'HARD']).optional(),
@@ -98,12 +103,12 @@ export const worksheets = router({
     }))
         .mutation(async ({ ctx, input }) => {
         const q = await ctx.db.worksheetQuestion.findFirst({
-            where: { id: input.questionId, artifact: { type: ArtifactType.WORKSHEET, workspace: { ownerId: ctx.session.user.id } } },
+            where: { id: input.worksheetQuestionId, artifact: { type: ArtifactType.WORKSHEET, workspace: { ownerId: ctx.session.user.id } } },
         });
         if (!q)
             throw new TRPCError({ code: 'NOT_FOUND' });
         return ctx.db.worksheetQuestion.update({
-            where: { id: input.questionId },
+            where: { id: input.worksheetQuestionId },
             data: {
                 prompt: input.prompt ?? q.prompt,
                 answer: input.answer ?? q.answer,
@@ -114,23 +119,23 @@ export const worksheets = router({
         });
     }),
     // Delete a question
-    deleteQuestion: authedProcedure
-        .input(z.object({ questionId: z.string().uuid() }))
+    deleteWorksheetQuestion: authedProcedure
+        .input(z.object({ worksheetQuestionId: z.string() }))
         .mutation(async ({ ctx, input }) => {
         const q = await ctx.db.worksheetQuestion.findFirst({
-            where: { id: input.questionId, artifact: { workspace: { ownerId: ctx.session.user.id } } },
+            where: { id: input.worksheetQuestionId, artifact: { workspace: { ownerId: ctx.session.user.id } } },
         });
         if (!q)
             throw new TRPCError({ code: 'NOT_FOUND' });
-        await ctx.db.worksheetQuestion.delete({ where: { id: input.questionId } });
+        await ctx.db.worksheetQuestion.delete({ where: { id: input.worksheetQuestionId } });
         return true;
     }),
     // Delete a worksheet set and its questions
-    deleteSet: authedProcedure
-        .input(z.object({ setId: z.string().uuid() }))
+    deleteWorksheet: authedProcedure
+        .input(z.object({ worksheetId: z.string() }))
         .mutation(async ({ ctx, input }) => {
         const deleted = await ctx.db.artifact.deleteMany({
-            where: { id: input.setId, type: ArtifactType.WORKSHEET, workspace: { ownerId: ctx.session.user.id } },
+            where: { id: input.worksheetId, type: ArtifactType.WORKSHEET, workspace: { ownerId: ctx.session.user.id } },
         });
         if (deleted.count === 0)
             throw new TRPCError({ code: 'NOT_FOUND' });

package/dist/routers/workspace.d.ts

@@ -4,7 +4,7 @@ export declare const workspace: import("@trpc/server").TRPCBuiltRouter<{
         session: any;
         req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
         res: import("express").Response<any, Record<string, any>>;
-        cookies: any;
+        cookies: Record<string, string | undefined>;
     };
     meta: object;
     errorShape: import("@trpc/server").TRPCDefaultErrorShape;

package/dist/routers/workspace.js

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import { TRPCError } from '@trpc/server';
 import { router, authedProcedure } from '../trpc.js';
 import { bucket } from '../lib/storage.js';
+import { ArtifactType } from '@prisma/client';
 export const workspace = router({
     // List current user's workspaces
     list: authedProcedure
@@ -25,6 +26,18 @@ export const workspace = router({
                 title: input.name,
                 description: input.description,
                 ownerId: ctx.session.user.id,
+                artifacts: {
+                    create: {
+                        type: ArtifactType.FLASHCARD_SET,
+                        title: "New Flashcard Set",
+                    },
+                    createMany: {
+                        data: [
+                            { type: ArtifactType.WORKSHEET, title: "Worksheet 1" },
+                            { type: ArtifactType.WORKSHEET, title: "Worksheet 2" },
+                        ],
+                    },
+                },
             },
         });
         return ws;

package/dist/server.d.ts

@@ -1 +1 @@
-export {};
+import 'dotenv/config';

package/dist/server.js

@@ -1,3 +1,4 @@
+import 'dotenv/config';
 import express from 'express';
 import cors from 'cors';
 import helmet from 'helmet';

package/dist/trpc.d.ts

@@ -4,7 +4,7 @@ export declare const router: import("@trpc/server").TRPCRouterBuilder<{
         session: any;
         req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
         res: import("express").Response<any, Record<string, any>>;
-        cookies: any;
+        cookies: Record<string, string | undefined>;
     };
     meta: object;
     errorShape: import("@trpc/server").TRPCDefaultErrorShape;
@@ -15,20 +15,20 @@ export declare const middleware: <$ContextOverrides>(fn: import("@trpc/server").
     session: any;
     req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
     res: import("express").Response<any, Record<string, any>>;
-    cookies: any;
+    cookies: Record<string, string | undefined>;
 }, object, object, $ContextOverrides, unknown>) => import("@trpc/server").TRPCMiddlewareBuilder<{
     db: import("@prisma/client").PrismaClient<import("@prisma/client").Prisma.PrismaClientOptions, never, import("@prisma/client/runtime/library").DefaultArgs>;
     session: any;
     req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
     res: import("express").Response<any, Record<string, any>>;
-    cookies: any;
+    cookies: Record<string, string | undefined>;
 }, object, $ContextOverrides, unknown>;
 export declare const publicProcedure: import("@trpc/server").TRPCProcedureBuilder<{
     db: import("@prisma/client").PrismaClient<import("@prisma/client").Prisma.PrismaClientOptions, never, import("@prisma/client/runtime/library").DefaultArgs>;
     session: any;
     req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
     res: import("express").Response<any, Record<string, any>>;
-    cookies: any;
+    cookies: Record<string, string | undefined>;
 }, object, object, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, false>;
 /** Exported authed procedure */
 export declare const authedProcedure: import("@trpc/server").TRPCProcedureBuilder<{
@@ -36,7 +36,7 @@ export declare const authedProcedure: import("@trpc/server").TRPCProcedureBuilde
     session: any;
     req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
     res: import("express").Response<any, Record<string, any>>;
-    cookies: any;
+    cookies: Record<string, string | undefined>;
 }, object, {
     session: any;
 }, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, false>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goscribe/server",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -22,6 +22,7 @@
     "@auth/express": "^0.11.0",
     "@auth/prisma-adapter": "^2.10.0",
     "@google-cloud/storage": "^7.17.0",
+    "@goscribe/server": "^1.0.7",
     "@prisma/client": "^6.14.0",
     "@trpc/server": "^11.5.0",
     "bcryptjs": "^3.0.2",

package/src/lib/auth.ts

@@ -7,7 +7,7 @@ export function verifyCustomAuthCookie(cookieValue: string | undefined): { userI
     return null;
   }
   
-  const secret = process.env.CUSTOM_AUTH_SECRET;
+  const secret = process.env.AUTH_SECRET;
   
   if (!secret) {
     return null;

package/src/routers/flashcards.ts

@@ -12,7 +12,7 @@ const ArtifactType = {
 
 export const flashcards = router({
   listSets: authedProcedure
-    .input(z.object({ workspaceId: z.string().uuid() }))
+    .input(z.object({ workspaceId: z.string() }))
     .query(async ({ ctx, input }) => {
       const workspace = await ctx.db.workspace.findFirst({
         where: { id: input.workspaceId, ownerId: ctx.session.user.id },
@@ -29,42 +29,22 @@ export const flashcards = router({
         orderBy: { updatedAt: 'desc' },
       });
     }),
-
-  createSet: authedProcedure
-    .input(z.object({ workspaceId: z.string().uuid(), title: z.string().min(1).max(120) }))
-    .mutation(async ({ ctx, input }) => {
-      const workspace = await ctx.db.workspace.findFirst({
-        where: { id: input.workspaceId, ownerId: ctx.session.user.id },
-      });
-      if (!workspace) throw new TRPCError({ code: 'NOT_FOUND' });
-      return ctx.db.artifact.create({
-        data: {
-          workspaceId: input.workspaceId,
-          type: ArtifactType.FLASHCARD_SET,
-          title: input.title,
-          createdById: ctx.session.user.id,
-        },
-      });
-    }),
-
-  getSet: authedProcedure
-    .input(z.object({ setId: z.string().uuid() }))
+  listCards: authedProcedure
+    .input(z.object({ workspaceId: z.string() }))
     .query(async ({ ctx, input }) => {
       const set = await ctx.db.artifact.findFirst({
-        where: {
-          id: input.setId,
-          type: ArtifactType.FLASHCARD_SET,
-          workspace: { ownerId: ctx.session.user.id },
+        where: { workspaceId: input.workspaceId, type: ArtifactType.FLASHCARD_SET, workspace: { ownerId: ctx.session.user.id } },
+        include: {
+          flashcards: true,
         },
-        include: { flashcards: true },
+        orderBy: { updatedAt: 'desc' },
       });
       if (!set) throw new TRPCError({ code: 'NOT_FOUND' });
-      return set;
+      return set.flashcards;
     }),
-
   createCard: authedProcedure
     .input(z.object({
-      setId: z.string().uuid(),
+      workspaceId: z.string(),
       front: z.string().min(1),
       back: z.string().min(1),
       tags: z.array(z.string()).optional(),
@@ -72,12 +52,18 @@ export const flashcards = router({
     }))
     .mutation(async ({ ctx, input }) => {
       const set = await ctx.db.artifact.findFirst({
-        where: { id: input.setId, type: ArtifactType.FLASHCARD_SET, workspace: { ownerId: ctx.session.user.id } },
+        where: { type: ArtifactType.FLASHCARD_SET, workspace: {
+          id: input.workspaceId,
+        } },
+        include: {
+          flashcards: true,
+        },
+        orderBy: { updatedAt: 'desc' },
       });
       if (!set) throw new TRPCError({ code: 'NOT_FOUND' });
       return ctx.db.flashcard.create({
         data: {
-          artifactId: input.setId,
+          artifactId: set.id,
           front: input.front,
           back: input.back,
           tags: input.tags ?? [],
@@ -88,7 +74,7 @@ export const flashcards = router({
 
   updateCard: authedProcedure
     .input(z.object({
-      cardId: z.string().uuid(),
+      cardId: z.string(),
       front: z.string().optional(),
       back: z.string().optional(),
       tags: z.array(z.string()).optional(),
@@ -111,7 +97,7 @@ export const flashcards = router({
     }),
 
   deleteCard: authedProcedure
-    .input(z.object({ cardId: z.string().uuid() }))
+    .input(z.object({ cardId: z.string() }))
     .mutation(async ({ ctx, input }) => {
       const card = await ctx.db.flashcard.findFirst({
         where: { id: input.cardId, artifact: { workspace: { ownerId: ctx.session.user.id } } },
@@ -120,16 +106,6 @@ export const flashcards = router({
       await ctx.db.flashcard.delete({ where: { id: input.cardId } });
       return true;
     }),
-
-  deleteSet: authedProcedure
-    .input(z.object({ setId: z.string().uuid() }))
-    .mutation(async ({ ctx, input }) => {
-      const deleted = await ctx.db.artifact.deleteMany({
-        where: { id: input.setId, type: ArtifactType.FLASHCARD_SET, workspace: { ownerId: ctx.session.user.id } },
-      });
-      if (deleted.count === 0) throw new TRPCError({ code: 'NOT_FOUND' });
-      return true;
-    }),
 });