@goscribe/server 1.0.8 → 1.0.9

package/dist/routers/_app.js

@@ -3,9 +3,15 @@ import { auth } from './auth.js';
 import { workspace } from './workspace.js';
 import { flashcards } from './flashcards.js';
 import { worksheets } from './worksheets.js';
+import { studyguide } from './studyguide.js';
+import { podcast } from './podcast.js';
+import { chat } from './chat.js';
 export const appRouter = router({
     auth,
     workspace,
     flashcards,
     worksheets,
+    studyguide,
+    podcast,
+    chat,
 });

package/dist/routers/ai-session.js

@@ -0,0 +1 @@
+"use strict";

package/dist/routers/auth.d.ts

@@ -33,6 +33,7 @@ export declare const auth: import("@trpc/server").TRPCBuiltRouter<{
             email: string | null;
             name: string | null;
             image: string | null;
+            token: string;
         };
         meta: object;
     }>;

package/dist/routers/auth.js

@@ -58,12 +58,13 @@ export const auth = router({
         }
         // Create custom auth token
         const authToken = createCustomAuthToken(user.id);
-        // Set the cookie immediately after successful login
+        const isProduction = (process.env.NODE_ENV === "production" || process.env.RENDER);
         const cookieValue = serialize("auth_token", authToken, {
             httpOnly: true,
-            secure: process.env.NODE_ENV === "production",
-            sameSite: "lax",
+            secure: isProduction, // true for production/HTTPS, false for localhost
+            sameSite: isProduction ? "none" : "lax", // none for cross-origin, lax for same-origin
             path: "/",
+            domain: isProduction ? "server-w8mz.onrender.com" : undefined,
             maxAge: 60 * 60 * 24 * 30, // 30 days
         });
         ctx.res.setHeader("Set-Cookie", cookieValue);
@@ -71,7 +72,8 @@ export const auth = router({
             id: user.id,
             email: user.email,
             name: user.name,
-            image: user.image
+            image: user.image,
+            token: authToken
         };
     }),
     getSession: publicProcedure.query(async ({ ctx }) => {

package/dist/routers/chat.d.ts

@@ -0,0 +1,171 @@
+export declare const chat: import("@trpc/server").TRPCBuiltRouter<{
+    ctx: {
+        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: Record<string, string | undefined>;
+    };
+    meta: object;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    transformer: true;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    getChannels: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            workspaceId: string;
+        };
+        output: {
+            name: string;
+            id: string;
+            createdAt: Date;
+            workspaceId: string;
+        }[];
+        meta: object;
+    }>;
+    getChannel: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            workspaceId?: string | undefined;
+            channelId?: string | undefined;
+        };
+        output: {
+            chats: ({
+                user: {
+                    name: string | null;
+                    id: string;
+                    image: string | null;
+                } | null;
+            } & {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                userId: string | null;
+                channelId: string;
+                message: string;
+            })[];
+        } & {
+            name: string;
+            id: string;
+            createdAt: Date;
+            workspaceId: string;
+        };
+        meta: object;
+    }>;
+    removeChannel: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            workspaceId: string;
+            channelId: string;
+        };
+        output: {
+            success: boolean;
+        };
+        meta: object;
+    }>;
+    editChannel: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            workspaceId: string;
+            channelId: string;
+            name: string;
+        };
+        output: {
+            chats: ({
+                user: {
+                    name: string | null;
+                    id: string;
+                    image: string | null;
+                } | null;
+            } & {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                userId: string | null;
+                channelId: string;
+                message: string;
+            })[];
+        } & {
+            name: string;
+            id: string;
+            createdAt: Date;
+            workspaceId: string;
+        };
+        meta: object;
+    }>;
+    createChannel: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            workspaceId: string;
+            name: string;
+        };
+        output: {
+            chats: ({
+                user: {
+                    name: string | null;
+                    id: string;
+                    image: string | null;
+                } | null;
+            } & {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                userId: string | null;
+                channelId: string;
+                message: string;
+            })[];
+        } & {
+            name: string;
+            id: string;
+            createdAt: Date;
+            workspaceId: string;
+        };
+        meta: object;
+    }>;
+    postMessage: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            channelId: string;
+            message: string;
+        };
+        output: {
+            user: {
+                name: string | null;
+                id: string;
+                image: string | null;
+            } | null;
+        } & {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            userId: string | null;
+            channelId: string;
+            message: string;
+        };
+        meta: object;
+    }>;
+    editMessage: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            chatId: string;
+            message: string;
+        };
+        output: {
+            user: {
+                name: string | null;
+                id: string;
+                image: string | null;
+            } | null;
+        } & {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            userId: string | null;
+            channelId: string;
+            message: string;
+        };
+        meta: object;
+    }>;
+    deleteMessage: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            chatId: string;
+        };
+        output: {
+            success: boolean;
+        };
+        meta: object;
+    }>;
+}>>;

package/dist/routers/chat.js

@@ -0,0 +1,270 @@
+import { TRPCError } from "@trpc/server";
+import { authedProcedure, router } from "../trpc.js";
+import z from "zod";
+import PusherService from "../lib/pusher.js";
+export const chat = router({
+    getChannels: authedProcedure
+        .input(z.object({ workspaceId: z.string() }))
+        .query(async ({ input, ctx }) => {
+        const channels = await ctx.db.channel.findMany({
+            where: { workspaceId: input.workspaceId },
+            include: { chats: {
+                    include: {
+                        user: {
+                            select: {
+                                id: true,
+                                name: true,
+                                image: true,
+                            }
+                        }
+                    }
+                } },
+        });
+        if (!channels) {
+            const defaultChannel = await ctx.db.channel.create({
+                data: { workspaceId: input.workspaceId, name: "General" },
+            });
+            return [defaultChannel];
+        }
+        return channels;
+    }),
+    getChannel: authedProcedure
+        .input(z.object({ workspaceId: z.string().optional(), channelId: z.string().optional() }))
+        .query(async ({ input, ctx }) => {
+        if (!input.channelId && input.workspaceId) {
+            const defaultChannel = await ctx.db.channel.create({
+                data: { workspaceId: input.workspaceId, name: "General" },
+                include: { chats: {
+                        include: {
+                            user: {
+                                select: {
+                                    id: true,
+                                    name: true,
+                                    image: true,
+                                }
+                            }
+                        }
+                    } },
+            });
+            await PusherService.emitTaskComplete(input.workspaceId, "new_channel", {
+                channelId: defaultChannel.id,
+                workspaceId: input.workspaceId,
+                name: "General",
+                createdAt: defaultChannel.createdAt,
+            });
+            return defaultChannel;
+        }
+        const channel = await ctx.db.channel.findUnique({
+            where: { id: input.channelId },
+            include: { chats: {
+                    include: {
+                        user: {
+                            select: {
+                                id: true,
+                                name: true,
+                                image: true,
+                            }
+                        }
+                    }
+                } },
+        });
+        if (!channel) {
+            throw new TRPCError({ code: "NOT_FOUND", message: "Channel not found" });
+        }
+        return channel;
+    }),
+    removeChannel: authedProcedure
+        .input(z.object({ workspaceId: z.string(), channelId: z.string() }))
+        .mutation(async ({ input, ctx }) => {
+        await ctx.db.channel.delete({ where: { id: input.channelId } });
+        await PusherService.emitTaskComplete(input.workspaceId, "remove_channel", {
+            channelId: input.channelId,
+            deletedAt: new Date().toISOString(),
+        });
+        return { success: true };
+    }),
+    editChannel: authedProcedure
+        .input(z.object({ workspaceId: z.string(), channelId: z.string(), name: z.string() }))
+        .mutation(async ({ input, ctx }) => {
+        const channel = await ctx.db.channel.update({
+            where: { id: input.channelId },
+            data: { name: input.name },
+            include: {
+                chats: {
+                    include: {
+                        user: {
+                            select: {
+                                id: true,
+                                name: true,
+                                image: true,
+                            }
+                        },
+                    }
+                }
+            }
+        });
+        await PusherService.emitTaskComplete(input.workspaceId, "edit_channel", {
+            channelId: input.channelId,
+            workspaceId: input.workspaceId,
+            name: input.name,
+        });
+        return channel;
+    }),
+    createChannel: authedProcedure
+        .input(z.object({ workspaceId: z.string(), name: z.string() }))
+        .mutation(async ({ input, ctx }) => {
+        const channel = await ctx.db.channel.create({
+            data: { workspaceId: input.workspaceId, name: input.name },
+            include: {
+                chats: {
+                    include: {
+                        user: {
+                            select: {
+                                id: true,
+                                name: true,
+                                image: true,
+                            }
+                        }
+                    }
+                }
+            }
+        });
+        // Notify via Pusher
+        await PusherService.emitTaskComplete(input.workspaceId, "new_channel", {
+            channelId: channel.id,
+            workspaceId: input.workspaceId,
+            name: input.name,
+            createdAt: channel.createdAt,
+        });
+        return channel;
+    }),
+    postMessage: authedProcedure
+        .input(z.object({ channelId: z.string(), message: z.string() }))
+        .mutation(async ({ input, ctx }) => {
+        const channel = await ctx.db.channel.findUnique({
+            where: { id: input.channelId },
+            include: {
+                chats: {
+                    include: {
+                        user: {
+                            select: {
+                                id: true,
+                                name: true,
+                                image: true,
+                            }
+                        }
+                    }
+                }
+            }
+        });
+        if (!channel) {
+            throw new TRPCError({ code: "NOT_FOUND", message: "Channel not found" });
+        }
+        const chat = await ctx.db.chat.create({
+            data: {
+                channelId: input.channelId,
+                userId: ctx.session.user.id,
+                message: input.message,
+            },
+            include: {
+                user: {
+                    select: {
+                        id: true,
+                        name: true,
+                        image: true,
+                    }
+                }
+            }
+        });
+        // Notify via Pusher
+        await PusherService.emitChannelEvent(input.channelId, "new_message", chat);
+        return chat;
+    }),
+    editMessage: authedProcedure
+        .input(z.object({ chatId: z.string(), message: z.string() }))
+        .mutation(async ({ input, ctx }) => {
+        const chat = await ctx.db.chat.findUnique({
+            where: { id: input.chatId },
+            include: {
+                user: {
+                    select: {
+                        id: true,
+                        name: true,
+                        image: true,
+                    }
+                }
+            }
+        });
+        if (!chat) {
+            throw new TRPCError({ code: "NOT_FOUND", message: "Chat message not found" });
+        }
+        if (chat.userId !== ctx.session.user.id) {
+            throw new TRPCError({ code: "FORBIDDEN", message: "Not your message to edit" });
+        }
+        const updatedChat = await ctx.db.chat.update({
+            where: { id: input.chatId },
+            data: { message: input.message },
+            include: {
+                user: {
+                    select: {
+                        id: true,
+                        name: true,
+                        image: true,
+                    }
+                }
+            }
+        });
+        // Notify via Pusher
+        await PusherService.emitChannelEvent(chat.channelId, "edit_message", {
+            chatId: updatedChat.id,
+            channelId: updatedChat.channelId,
+            userId: updatedChat.userId,
+            message: input.message,
+            updatedAt: updatedChat.updatedAt,
+            user: {
+                id: ctx.session.user.id,
+                name: updatedChat.user?.name,
+                image: updatedChat.user?.image,
+            },
+        });
+        return updatedChat;
+    }),
+    deleteMessage: authedProcedure
+        .input(z.object({ chatId: z.string() }))
+        .mutation(async ({ input, ctx }) => {
+        const chat = await ctx.db.chat.findUnique({
+            where: { id: input.chatId },
+            include: {
+                user: {
+                    select: {
+                        id: true,
+                        name: true,
+                        image: true,
+                    }
+                },
+            }
+        });
+        if (!chat) {
+            throw new TRPCError({ code: "NOT_FOUND", message: "Chat message not found" });
+        }
+        if (chat.userId !== ctx.session.user.id) {
+            throw new TRPCError({ code: "FORBIDDEN", message: "Not your message to delete" });
+        }
+        await ctx.db.chat.delete({
+            where: { id: input.chatId },
+        });
+        // Notify via Pusher
+        await PusherService.emitChannelEvent(chat.channelId, "delete_message", {
+            chatId: chat.id,
+            channelId: chat.channelId,
+            userId: chat.userId,
+            deletedAt: new Date().toISOString(),
+            user: {
+                id: ctx.session.user.id,
+                name: chat.user?.name,
+                image: chat.user?.image,
+            },
+        });
+        return { success: true };
+    }),
+});

package/dist/routers/flashcards.d.ts

@@ -29,9 +29,12 @@ export declare const flashcards: import("@trpc/server").TRPCBuiltRouter<{
             createdAt: Date;
             updatedAt: Date;
             title: string;
+            description: string | null;
             workspaceId: string;
             type: import("@prisma/client").$Enums.ArtifactType;
             isArchived: boolean;
+            difficulty: import("@prisma/client").$Enums.Difficulty | null;
+            estimatedTime: string | null;
             createdById: string | null;
         })[];
         meta: object;
@@ -96,4 +99,38 @@ export declare const flashcards: import("@trpc/server").TRPCBuiltRouter<{
         output: boolean;
         meta: object;
     }>;
+    deleteSet: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            setId: string;
+        };
+        output: boolean;
+        meta: object;
+    }>;
+    generateFromPrompt: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            workspaceId: string;
+            prompt: string;
+            numCards?: number | undefined;
+            difficulty?: "easy" | "medium" | "hard" | undefined;
+            title?: string | undefined;
+            tags?: string[] | undefined;
+        };
+        output: {
+            artifact: {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                title: string;
+                description: string | null;
+                workspaceId: string;
+                type: import("@prisma/client").$Enums.ArtifactType;
+                isArchived: boolean;
+                difficulty: import("@prisma/client").$Enums.Difficulty | null;
+                estimatedTime: string | null;
+                createdById: string | null;
+            };
+            createdCards: number;
+        };
+        meta: object;
+    }>;
 }>>;

package/dist/routers/flashcards.js

@@ -1,6 +1,8 @@
 import { z } from 'zod';
 import { TRPCError } from '@trpc/server';
 import { router, authedProcedure } from '../trpc.js';
+import { aiSessionService } from '../lib/ai-session.js';
+import PusherService from '../lib/pusher.js';
 // Prisma enum values mapped manually to avoid type import issues in ESM
 const ArtifactType = {
     STUDY_GUIDE: 'STUDY_GUIDE',
@@ -108,4 +110,130 @@ 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;
+    }),
+    // Generate a flashcard set from a user prompt
+    generateFromPrompt: authedProcedure
+        .input(z.object({
+        workspaceId: z.string(),
+        prompt: z.string().min(1),
+        numCards: z.number().int().min(1).max(50).default(10),
+        difficulty: z.enum(['easy', 'medium', 'hard']).default('medium'),
+        title: z.string().optional(),
+        tags: z.array(z.string()).optional(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        // Verify workspace ownership
+        const workspace = await ctx.db.workspace.findFirst({
+            where: { id: input.workspaceId, ownerId: ctx.session.user.id },
+        });
+        if (!workspace)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        // Pusher start
+        await PusherService.emitTaskComplete(input.workspaceId, 'flash_card_load_start', { source: 'prompt' });
+        const flashcardCurrent = await ctx.db.artifact.findFirst({
+            where: {
+                workspaceId: input.workspaceId,
+                type: ArtifactType.FLASHCARD_SET,
+            },
+            select: {
+                flashcards: true,
+            },
+            orderBy: {
+                updatedAt: 'desc',
+            },
+        });
+        const formattedPreviousCards = flashcardCurrent?.flashcards.map((card) => ({
+            front: card.front,
+            back: card.back,
+        }));
+        const partialPrompt = `
+      This is the users previous flashcards, avoid repeating any existing cards.
+      Please generate ${input.numCards} new cards,
+      Of a ${input.difficulty} difficulty,
+      Of a ${input.tags?.join(', ')} tag,
+      Of a ${input.title} title.
+      ${formattedPreviousCards?.map((card) => `Front: ${card.front}\nBack: ${card.back}`).join('\n')}
+
+      The user has also left you this prompt: ${input.prompt}
+      `;
+        // Init AI session and seed with prompt as instruction
+        const session = await aiSessionService.initSession(input.workspaceId);
+        await aiSessionService.setInstruction(session.id, partialPrompt);
+        await aiSessionService.startLLMSession(session.id);
+        const currentCards = flashcardCurrent?.flashcards.length || 0;
+        const newCards = input.numCards - currentCards;
+        // Generate
+        await PusherService.emitTaskComplete(input.workspaceId, 'flash_card_info', { status: 'generating', numCards: input.numCards, difficulty: input.difficulty });
+        const content = await aiSessionService.generateFlashcardQuestions(session.id, input.numCards, input.difficulty);
+        // Previous cards
+        // Create artifact
+        const artifact = await ctx.db.artifact.create({
+            data: {
+                workspaceId: input.workspaceId,
+                type: ArtifactType.FLASHCARD_SET,
+                title: input.title || `Flashcards - ${new Date().toLocaleString()}`,
+                createdById: ctx.session.user.id,
+                flashcards: {
+                    create: flashcardCurrent?.flashcards.map((card) => ({
+                        front: card.front,
+                        back: card.back,
+                    })),
+                },
+            },
+        });
+        // Parse and create cards
+        let createdCards = 0;
+        try {
+            const flashcardData = JSON.parse(content);
+            for (let i = 0; i < Math.min(flashcardData.length, input.numCards); i++) {
+                const card = flashcardData[i];
+                const front = card.term || card.front || card.question || card.prompt || `Question ${i + 1}`;
+                const back = card.definition || card.back || card.answer || card.solution || `Answer ${i + 1}`;
+                await ctx.db.flashcard.create({
+                    data: {
+                        artifactId: artifact.id,
+                        front,
+                        back,
+                        order: i,
+                        tags: input.tags ?? ['ai-generated', input.difficulty],
+                    },
+                });
+                createdCards++;
+            }
+        }
+        catch {
+            // Fallback to text parsing if JSON fails
+            const lines = content.split('\n').filter(line => line.trim());
+            for (let i = 0; i < Math.min(lines.length, input.numCards); i++) {
+                const line = lines[i];
+                if (line.includes(' - ')) {
+                    const [front, back] = line.split(' - ');
+                    await ctx.db.flashcard.create({
+                        data: {
+                            artifactId: artifact.id,
+                            front: front.trim(),
+                            back: back.trim(),
+                            order: i,
+                            tags: input.tags ?? ['ai-generated', input.difficulty],
+                        },
+                    });
+                    createdCards++;
+                }
+            }
+        }
+        // Pusher complete
+        await PusherService.emitFlashcardComplete(input.workspaceId, artifact);
+        // Cleanup AI session (best-effort)
+        aiSessionService.deleteSession(session.id);
+        return { artifact, createdCards };
+    }),
 });