@goscribe/server 1.3.3 → 1.5.0

package/dist/routers/chat.js

@@ -1,246 +1,32 @@
-import { TRPCError } from "@trpc/server";
-import { authedProcedure, router } from "../trpc.js";
-import z from "zod";
-import PusherService from "../lib/pusher.js";
+import z from 'zod';
+import { authedProcedure, router } from '../trpc.js';
+import { ChatService } from '../services/artifacts/chat.service.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,
-                                profilePicture: {
-                                    select: {
-                                        id: true,
-                                        name: true,
-                                        url: true,
-                                    }
-                                }
-                            }
-                        }
-                    }
-                } },
-        });
-        if (!channels) {
-            const defaultChannel = await ctx.db.channel.create({
-                data: { workspaceId: input.workspaceId, name: "General" },
-            });
-            return [defaultChannel];
-        }
-        return channels;
-    }),
+        .query(({ ctx, input }) => new ChatService(ctx.db).getChannels(input.workspaceId)),
     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,
-                                }
-                            }
-                        }
-                    } },
-            });
-            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,
-                            }
-                        }
-                    }
-                } },
-        });
-        if (!channel) {
-            throw new TRPCError({ code: "NOT_FOUND", message: "Channel not found" });
-        }
-        return channel;
-    }),
+        .input(z.object({
+        workspaceId: z.string().optional(),
+        channelId: z.string().optional(),
+    }))
+        .query(({ ctx, input }) => new ChatService(ctx.db).getChannel(input)),
     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 };
-    }),
+        .mutation(({ ctx, input }) => new ChatService(ctx.db).removeChannel(input)),
     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,
-                            }
-                        },
-                    }
-                }
-            }
-        });
-        await PusherService.emitTaskComplete(input.workspaceId, "edit_channel", {
-            channelId: input.channelId,
-            workspaceId: input.workspaceId,
-            name: input.name,
-        });
-        return channel;
-    }),
+        .mutation(({ ctx, input }) => new ChatService(ctx.db).editChannel(input)),
     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,
-                            }
-                        }
-                    }
-                }
-            }
-        });
-        // Notify via Pusher
-        await PusherService.emitTaskComplete(input.workspaceId, "new_channel", {
-            channelId: channel.id,
-            workspaceId: input.workspaceId,
-            name: input.name,
-            createdAt: channel.createdAt,
-        });
-        return channel;
-    }),
+        .mutation(({ ctx, input }) => new ChatService(ctx.db).createChannel(input)),
     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,
-                            }
-                        }
-                    }
-                }
-            }
-        });
-        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,
-                    }
-                }
-            }
-        });
-        // Notify via Pusher
-        await PusherService.emitChannelEvent(input.channelId, "new_message", chat);
-        return chat;
-    }),
+        .mutation(({ ctx, input }) => new ChatService(ctx.db).postMessage(ctx.session.user.id, input)),
     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,
-                    }
-                }
-            }
-        });
-        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,
-                    }
-                }
-            }
-        });
-        // Notify via Pusher
-        await PusherService.emitChannelEvent(chat.channelId, "edit_message", updatedChat);
-        return updatedChat;
-    }),
+        .mutation(({ ctx, input }) => new ChatService(ctx.db).editMessage(ctx.session.user.id, input)),
     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,
-                    }
-                },
-            }
-        });
-        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", chat);
-        return { success: true };
-    }),
+        .mutation(({ ctx, input }) => new ChatService(ctx.db).deleteMessage(ctx.session.user.id, input.chatId)),
 });

package/dist/routers/copilot.d.ts

@@ -1,6 +1,5 @@
-import type { Context } from "../context.js";
 export declare const copilot: import("@trpc/server").TRPCBuiltRouter<{
-    ctx: Context;
+    ctx: import("../context.js").Context;
     meta: object;
     errorShape: {
         data: {
@@ -71,8 +70,9 @@ export declare const copilot: import("@trpc/server").TRPCBuiltRouter<{
             context: {
                 workspaceId: string;
                 artifactId: string;
-                artifactType: "flashcards" | "worksheet" | "study-guide" | "notes";
+                artifactType: "flashcards" | "worksheet" | "study-guide";
                 documentContent: string;
+                documentPlainText?: string | undefined;
                 selectedText?: string | undefined;
                 viewportText?: string | undefined;
                 cursorPosition?: {
@@ -91,9 +91,8 @@ export declare const copilot: import("@trpc/server").TRPCBuiltRouter<{
         output: {
             answer: string;
             highlights: {
-                start: number;
-                end: number;
-                label?: string | undefined;
+                text: string;
+                label?: string;
             }[];
         };
         meta: object;
@@ -103,8 +102,9 @@ export declare const copilot: import("@trpc/server").TRPCBuiltRouter<{
             context: {
                 workspaceId: string;
                 artifactId: string;
-                artifactType: "flashcards" | "worksheet" | "study-guide" | "notes";
+                artifactType: "flashcards" | "worksheet" | "study-guide";
                 documentContent: string;
+                documentPlainText?: string | undefined;
                 selectedText?: string | undefined;
                 viewportText?: string | undefined;
                 cursorPosition?: {
@@ -130,8 +130,9 @@ export declare const copilot: import("@trpc/server").TRPCBuiltRouter<{
             context: {
                 workspaceId: string;
                 artifactId: string;
-                artifactType: "flashcards" | "worksheet" | "study-guide" | "notes";
+                artifactType: "flashcards" | "worksheet" | "study-guide";
                 documentContent: string;
+                documentPlainText?: string | undefined;
                 selectedText?: string | undefined;
                 viewportText?: string | undefined;
                 cursorPosition?: {
@@ -150,9 +151,8 @@ export declare const copilot: import("@trpc/server").TRPCBuiltRouter<{
         output: {
             answer: string;
             highlights: {
-                start: number;
-                end: number;
-                label?: string | undefined;
+                text: string;
+                label?: string;
             }[];
         };
         meta: object;
@@ -162,8 +162,9 @@ export declare const copilot: import("@trpc/server").TRPCBuiltRouter<{
             context: {
                 workspaceId: string;
                 artifactId: string;
-                artifactType: "flashcards" | "worksheet" | "study-guide" | "notes";
+                artifactType: "flashcards" | "worksheet" | "study-guide";
                 documentContent: string;
+                documentPlainText?: string | undefined;
                 selectedText?: string | undefined;
                 viewportText?: string | undefined;
                 cursorPosition?: {
@@ -187,10 +188,10 @@ export declare const copilot: import("@trpc/server").TRPCBuiltRouter<{
                 id: string;
                 createdAt: Date;
                 artifactId: string;
+                tags: string[];
                 order: number;
                 front: string;
                 back: string;
-                tags: string[];
                 acceptedAnswers: string[];
             }[];
         };