@goscribe/server 1.0.7 → 1.0.9

package/dist/routers/_app.js

@@ -1,11 +1,17 @@
 import { router } from '../trpc.js';
 import { auth } from './auth.js';
 import { workspace } from './workspace.js';
-import { flashcards } from './flashcards';
-import { worksheets } from './worksheets';
+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

@@ -4,7 +4,7 @@ export declare const auth: 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;
@@ -29,22 +29,17 @@ export declare const auth: import("@trpc/server").TRPCBuiltRouter<{
             password: string;
         };
         output: {
-            id: any;
-            session: any;
-            user: {
-                id: string;
-                email: string | null;
-                name: string | null;
-                image: string | null;
-            };
+            id: string;
+            email: string | null;
+            name: string | null;
+            image: string | null;
+            token: string;
         };
         meta: object;
     }>;
     getSession: import("@trpc/server").TRPCQueryProcedure<{
         input: void;
         output: {
-            id: any;
-            userId: any;
             user: {
                 id: string;
                 email: string | null;
@@ -54,4 +49,11 @@ export declare const auth: import("@trpc/server").TRPCBuiltRouter<{
         };
         meta: object;
     }>;
+    logout: import("@trpc/server").TRPCMutationProcedure<{
+        input: void;
+        output: {
+            success: boolean;
+        };
+        meta: object;
+    }>;
 }>>;

package/dist/routers/auth.js

@@ -2,6 +2,19 @@ import { z } from 'zod';
 import { router, publicProcedure } from '../trpc.js';
 import bcrypt from 'bcryptjs';
 import { serialize } from 'cookie';
+import crypto from 'node:crypto';
+// Helper to create custom auth token
+function createCustomAuthToken(userId) {
+    const secret = process.env.AUTH_SECRET;
+    if (!secret) {
+        throw new Error("AUTH_SECRET is not set");
+    }
+    const base64UserId = Buffer.from(userId, 'utf8').toString('base64url');
+    const hmac = crypto.createHmac('sha256', secret);
+    hmac.update(base64UserId);
+    const signature = hmac.digest('hex');
+    return `${base64UserId}.${signature}`;
+}
 export const auth = router({
     signup: publicProcedure
         .input(z.object({
@@ -43,39 +56,55 @@ export const auth = router({
         if (!valid) {
             throw new Error("Invalid credentials");
         }
-        const session = await ctx.db.session.create({
-            data: {
-                userId: user.id,
-                expires: new Date(Date.now() + 1000 * 60 * 60 * 24 * 30),
-            },
+        // Create custom auth token
+        const authToken = createCustomAuthToken(user.id);
+        const isProduction = (process.env.NODE_ENV === "production" || process.env.RENDER);
+        const cookieValue = serialize("auth_token", authToken, {
+            httpOnly: true,
+            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
         });
-        return { id: session.id, session: session.id, user: { id: user.id, email: user.email, name: user.name, image: user.image } };
+        ctx.res.setHeader("Set-Cookie", cookieValue);
+        return {
+            id: user.id,
+            email: user.email,
+            name: user.name,
+            image: user.image,
+            token: authToken
+        };
     }),
     getSession: publicProcedure.query(async ({ ctx }) => {
-        const session = await ctx.db.session.findUnique({
-            where: {
-                id: ctx.session?.id,
-            },
-        });
-        if (!session) {
-            throw new Error("Session not found");
-        }
-        if (session.expires < new Date()) {
-            throw new Error("Session expired");
+        // Just return the current session from context
+        if (!ctx.session) {
+            throw new Error("No session found");
         }
         const user = await ctx.db.user.findUnique({
-            where: { id: session.userId },
+            where: { id: ctx.session.user.id },
         });
         if (!user) {
             throw new Error("User not found");
         }
-        ctx.res.setHeader("Set-Cookie", serialize("auth_token", session.id, {
+        return {
+            user: {
+                id: user.id,
+                email: user.email,
+                name: user.name,
+                image: user.image
+            }
+        };
+    }),
+    logout: publicProcedure.mutation(async ({ ctx }) => {
+        // Clear the auth cookie
+        ctx.res.setHeader("Set-Cookie", serialize("auth_token", "", {
             httpOnly: true,
             secure: process.env.NODE_ENV === "production",
-            sameSite: "none", // cross-origin XHR needs None
+            sameSite: "lax",
             path: "/",
-            maxAge: 60 * 60 * 24 * 7,
+            maxAge: 0, // Expire immediately
         }));
-        return { id: session.id, userId: session.userId, user: { id: user.id, email: user.email, name: user.name, image: user.image } };
+        return { success: true };
     }),
 });

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 };
+    }),
+});