@goscribe/server 1.0.6 → 1.0.8

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 },
@@ -20,45 +20,31 @@ export const flashcards = router({
       if (!workspace) 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(),
@@ -66,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 ?? [],
@@ -82,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(),
@@ -105,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 } } },
@@ -114,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;
-    }),
 });
 
 

package/src/routers/worksheets.ts

@@ -15,22 +15,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 },
@@ -47,25 +52,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) throw new TRPCError({ code: 'NOT_FOUND' });
-      return set;
+      if (!worksheet) throw new TRPCError({ code: 'NOT_FOUND' });
+      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(),
@@ -73,13 +78,13 @@ 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) throw new TRPCError({ code: 'NOT_FOUND' });
+      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) as any,
@@ -90,9 +95,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(),
@@ -101,11 +106,11 @@ 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,
@@ -117,23 +122,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' });
       return true;

package/src/routers/workspace.ts

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import { TRPCError } from '@trpc/server';
 import { router, publicProcedure, authedProcedure } from '../trpc.js';
 import { bucket } from '../lib/storage.js';
+import { ArtifactType } from '@prisma/client';
 
 export const workspace = router({
   // List current user's workspaces
@@ -27,6 +28,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/src/server.ts

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

package/dist/context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAGjF,wBAAsB,aAAa,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,2BAA2B;;;;;GAI5E;AAED,MAAM,MAAM,OAAO,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC,CAAC"}

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChD,YAAY,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACnD,YAAY,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/lib/auth.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/lib/auth.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,UAAU,0HA0BnB,CAAA"}

package/dist/lib/file.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../../src/lib/file.ts"],"names":[],"mappings":""}

package/dist/lib/prisma.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"prisma.d.ts","sourceRoot":"","sources":["../../src/lib/prisma.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAI9C,eAAO,MAAM,MAAM,gIAIf,CAAC"}

package/dist/lib/storage.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../src/lib/storage.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAEhD,eAAO,MAAM,OAAO,SAMlB,CAAC;AAEH,eAAO,MAAM,MAAM,wCAA0C,CAAC"}

package/dist/routers/_app.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"_app.d.ts","sourceRoot":"","sources":["../../src/routers/_app.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAKrE,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAGpB,CAAC;AAGH,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC;AACzC,MAAM,MAAM,YAAY,GAAG,iBAAiB,CAAC,SAAS,CAAC,CAAC;AACxD,MAAM,MAAM,aAAa,GAAG,kBAAkB,CAAC,SAAS,CAAC,CAAC"}

package/dist/routers/auth.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/routers/auth.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;GA4Bf,CAAC"}

package/dist/routers/sample.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sampleRouter = void 0;
-const zod_1 = require("zod");
-const trpc_1 = require("../trpc");
-exports.sampleRouter = (0, trpc_1.router)({
-    // GET-like: query without input
-    hello: trpc_1.publicProcedure.query(() => {
-        return { message: 'Hello from tRPC + Express 👋' };
-    }),
-    // Mutation with Zod input
-    echo: trpc_1.publicProcedure
-        .input(zod_1.z.object({ text: zod_1.z.string().min(1) }))
-        .mutation(({ input }) => {
-        return { echoed: input.text };
-    }),
-    // Authed query
-    me: trpc_1.authedProcedure.query(({ ctx }) => {
-        return { userId: ctx.user.id, role: ctx.user.role };
-    }),
-});

package/dist/routers/workspace.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"workspace.d.ts","sourceRoot":"","sources":["../../src/routers/workspace.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuJpB,CAAC"}

package/dist/server.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":""}

package/dist/trpc.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"trpc.d.ts","sourceRoot":"","sources":["../src/trpc.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,MAAM;;;;;;;;;;EAAW,CAAC;AAC/B,eAAO,MAAM,UAAU;;;;;;;;;;sCAAe,CAAC;AACvC,eAAO,MAAM,eAAe;;;;;yLAAc,CAAC;AAsB3C,gCAAgC;AAChC,eAAO,MAAM,eAAe;;;;;;;;;;yKAAgC,CAAC"}