@goscribe/server 1.3.4 → 1.6.0

package/src/routers/chat.ts

@@ -1,251 +1,48 @@
-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;
-        }),
-    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,
-                                }
-                            }
-                        }
-                    } },
-                });
+  getChannels: authedProcedure
+    .input(z.object({ workspaceId: z.string() }))
+    .query(({ ctx, input }) => new ChatService(ctx.db).getChannels(input.workspaceId)),
 
-                await PusherService.emitTaskComplete(input.workspaceId, "new_channel", {
-                    channelId: defaultChannel.id,
-                    workspaceId: input.workspaceId,
-                    name: "General",
-                    createdAt: defaultChannel.createdAt,
-                });
+  getChannel: authedProcedure
+    .input(
+      z.object({
+        workspaceId: z.string().optional(),
+        channelId: z.string().optional(),
+      }),
+    )
+    .query(({ ctx, input }) => new ChatService(ctx.db).getChannel(input)),
 
-                return defaultChannel;
-            }
-            const channel = await ctx.db.channel.findUnique({
-                where: { id: input.channelId },
-                include: { chats: {
-                    include: {
-                        user: {
-                            select: {
-                                id: true,
-                                name: true,
-                            }
-                        }
-                    }
-                } },
-            });
+  removeChannel: authedProcedure
+    .input(z.object({ workspaceId: z.string(), channelId: z.string() }))
+    .mutation(({ ctx, input }) => new ChatService(ctx.db).removeChannel(input)),
 
-            if (!channel) {
-                throw new TRPCError({ code: "NOT_FOUND", message: "Channel not found" });
-            }
+  editChannel: authedProcedure
+    .input(z.object({ workspaceId: z.string(), channelId: z.string(), name: z.string() }))
+    .mutation(({ ctx, input }) => new ChatService(ctx.db).editChannel(input)),
 
-            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,
-                                }
-                            },
-                        }
-                    }
-                }
-            });
-            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,
-                                }
-                            }
-                        }
-                    }
-                }
-            });
-            // 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,
-                                }
-                            }
-                        }
-                    }
-                }
-            });
-            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;
-        }),
-    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;
-        }),
-    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 };
-        }),
-});
+  createChannel: authedProcedure
+    .input(z.object({ workspaceId: z.string(), name: z.string() }))
+    .mutation(({ ctx, input }) => new ChatService(ctx.db).createChannel(input)),
+
+  postMessage: authedProcedure
+    .input(z.object({ channelId: z.string(), message: z.string() }))
+    .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(({ ctx, input }) =>
+      new ChatService(ctx.db).editMessage(ctx.session.user.id, input),
+    ),
+
+  deleteMessage: authedProcedure
+    .input(z.object({ chatId: z.string() }))
+    .mutation(({ ctx, input }) =>
+      new ChatService(ctx.db).deleteMessage(ctx.session.user.id, input.chatId),
+    ),
+});