@studious-lms/server 1.1.26 → 1.2.6

package/dist/routers/notifications.d.ts

@@ -27,12 +27,12 @@ export declare const notificationRouter: import("@trpc/server").TRPCBuiltRouter<
             };
         } & {
             id: string;
+            createdAt: Date;
             title: string;
             content: string;
-            createdAt: Date;
+            read: boolean;
             senderId: string | null;
             receiverId: string;
-            read: boolean;
         })[];
         meta: object;
     }>;
@@ -49,12 +49,12 @@ export declare const notificationRouter: import("@trpc/server").TRPCBuiltRouter<
             };
         } & {
             id: string;
+            createdAt: Date;
             title: string;
             content: string;
-            createdAt: Date;
+            read: boolean;
             senderId: string | null;
             receiverId: string;
-            read: boolean;
         }) | null;
         meta: object;
     }>;
@@ -66,12 +66,12 @@ export declare const notificationRouter: import("@trpc/server").TRPCBuiltRouter<
         };
         output: {
             id: string;
+            createdAt: Date;
             title: string;
             content: string;
-            createdAt: Date;
+            read: boolean;
             senderId: string | null;
             receiverId: string;
-            read: boolean;
         };
         meta: object;
     }>;
@@ -90,12 +90,12 @@ export declare const notificationRouter: import("@trpc/server").TRPCBuiltRouter<
         };
         output: {
             id: string;
+            createdAt: Date;
             title: string;
             content: string;
-            createdAt: Date;
+            read: boolean;
             senderId: string | null;
             receiverId: string;
-            read: boolean;
         };
         meta: object;
     }>;

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

@@ -1 +1 @@
-{"version":3,"file":"notifications.d.ts","sourceRoot":"","sources":["../../src/routers/notifications.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwF7B,CAAA"}
+{"version":3,"file":"notifications.d.ts","sourceRoot":"/","sources":["routers/notifications.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgC7B,CAAC"}

package/dist/routers/notifications.js

@@ -1,91 +1,30 @@
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="2769d494-a91e-58cf-99e2-7fa58208de9a")}catch(e){}}();
 import { createTRPCRouter, protectedProcedure } from "../trpc.js";
-import { prisma } from "../lib/prisma.js";
 import { z } from "zod";
+import { listNotifications, getNotification, sendNotification, sendToMultiple, markAsRead, } from "../services/notification.js";
 export const notificationRouter = createTRPCRouter({
-    list: protectedProcedure.query(async ({ ctx }) => {
-        const notifications = await prisma.notification.findMany({
-            where: {
-                receiverId: ctx.user.id,
-            },
-            orderBy: {
-                createdAt: "desc",
-            },
-            include: {
-                sender: {
-                    select: {
-                        username: true,
-                    },
-                },
-                receiver: {
-                    select: {
-                        username: true,
-                    },
-                },
-            },
-        });
-        return notifications;
-    }),
-    get: protectedProcedure.input(z.object({
-        id: z.string(),
-    })).query(async ({ ctx, input }) => {
-        const { id } = input;
-        const notification = await prisma.notification.findUnique({
-            where: {
-                id,
-            },
-            include: {
-                sender: {
-                    select: {
-                        username: true,
-                    },
-                },
-                receiver: {
-                    select: {
-                        username: true,
-                    },
-                },
-            },
-        });
-        return notification;
-    }),
-    sendTo: protectedProcedure.input(z.object({
+    list: protectedProcedure.query(({ ctx }) => listNotifications(ctx.user.id)),
+    get: protectedProcedure
+        .input(z.object({ id: z.string() }))
+        .query(({ input }) => getNotification(input.id)),
+    sendTo: protectedProcedure
+        .input(z.object({
         receiverId: z.string(),
         title: z.string(),
         content: z.string(),
-    })).mutation(async ({ ctx, input }) => {
-        const { receiverId, title, content } = input;
-        const notification = await prisma.notification.create({
-            data: {
-                receiverId,
-                title,
-                content,
-            },
-        });
-        return notification;
-    }),
-    sendToMultiple: protectedProcedure.input(z.object({
+    }))
+        .mutation(({ input }) => sendNotification(input)),
+    sendToMultiple: protectedProcedure
+        .input(z.object({
         receiverIds: z.array(z.string()),
         title: z.string(),
         content: z.string(),
-    })).mutation(async ({ ctx, input }) => {
-        const { receiverIds, title, content } = input;
-        const notifications = await prisma.notification.createMany({
-            data: receiverIds.map(receiverId => ({
-                receiverId,
-                title,
-                content,
-            })),
-        });
-        return notifications;
-    }),
-    markAsRead: protectedProcedure.input(z.object({
-        id: z.string(),
-    })).mutation(async ({ ctx, input }) => {
-        const { id } = input;
-        const notification = await prisma.notification.update({
-            where: { id },
-            data: { read: true },
-        });
-        return notification;
-    }),
+    }))
+        .mutation(({ input }) => sendToMultiple(input)),
+    markAsRead: protectedProcedure
+        .input(z.object({ id: z.string() }))
+        .mutation(({ input }) => markAsRead(input.id)),
 });
+//# sourceMappingURL=notifications.js.map
+//# debugId=2769d494-a91e-58cf-99e2-7fa58208de9a

package/dist/routers/notifications.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"notifications.js","sources":["routers/notifications.ts"],"sourceRoot":"/","sourcesContent":["import { createTRPCRouter, protectedProcedure } from \"../trpc.js\";\nimport { z } from \"zod\";\nimport {\n  listNotifications,\n  getNotification,\n  sendNotification,\n  sendToMultiple,\n  markAsRead,\n} from \"../services/notification.js\";\n\nexport const notificationRouter = createTRPCRouter({\n  list: protectedProcedure.query(({ ctx }) =>\n    listNotifications(ctx.user!.id)\n  ),\n\n  get: protectedProcedure\n    .input(z.object({ id: z.string() }))\n    .query(({ input }) => getNotification(input.id)),\n\n  sendTo: protectedProcedure\n    .input(\n      z.object({\n        receiverId: z.string(),\n        title: z.string(),\n        content: z.string(),\n      })\n    )\n    .mutation(({ input }) => sendNotification(input)),\n\n  sendToMultiple: protectedProcedure\n    .input(\n      z.object({\n        receiverIds: z.array(z.string()),\n        title: z.string(),\n        content: z.string(),\n      })\n    )\n    .mutation(({ input }) => sendToMultiple(input)),\n\n  markAsRead: protectedProcedure\n    .input(z.object({ id: z.string() }))\n    .mutation(({ input }) => markAsRead(input.id)),\n});\n"],"names":[],"mappings":";;AAAA,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAClE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EACL,iBAAiB,EACjB,eAAe,EACf,gBAAgB,EAChB,cAAc,EACd,UAAU,GACX,MAAM,6BAA6B,CAAC;AAErC,MAAM,CAAC,MAAM,kBAAkB,GAAG,gBAAgB,CAAC;IACjD,IAAI,EAAE,kBAAkB,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,CACzC,iBAAiB,CAAC,GAAG,CAAC,IAAK,CAAC,EAAE,CAAC,CAChC;IAED,GAAG,EAAE,kBAAkB;SACpB,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;SACnC,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,eAAe,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IAElD,MAAM,EAAE,kBAAkB;SACvB,KAAK,CACJ,CAAC,CAAC,MAAM,CAAC;QACP,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE;QACtB,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE;QACjB,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;KACpB,CAAC,CACH;SACA,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;IAEnD,cAAc,EAAE,kBAAkB;SAC/B,KAAK,CACJ,CAAC,CAAC,MAAM,CAAC;QACP,WAAW,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;QAChC,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE;QACjB,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;KACpB,CAAC,CACH;SACA,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;IAEjD,UAAU,EAAE,kBAAkB;SAC3B,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;SACnC,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;CACjD,CAAC,CAAC","debug_id":"2769d494-a91e-58cf-99e2-7fa58208de9a"}

package/dist/routers/section.d.ts

@@ -16,57 +16,71 @@ export declare const sectionRouter: import("@trpc/server").TRPCBuiltRouter<{
     };
     transformer: false;
 }, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    exists: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            [x: string]: unknown;
+            classId: string;
+            id: string;
+        };
+        output: boolean;
+        meta: object;
+    }>;
     create: import("@trpc/server").TRPCMutationProcedure<{
         input: {
-            name: string;
+            [x: string]: unknown;
             classId: string;
+            name: string;
+            id?: string | undefined;
             color?: string | undefined;
         };
         output: {
             id: string;
+            classId: string;
             name: string;
             color: string | null;
-            classId: string;
             order: number | null;
         };
         meta: object;
     }>;
     reorder: import("@trpc/server").TRPCMutationProcedure<{
         input: {
+            [x: string]: unknown;
             classId: string;
             movedId: string;
-            position: "start" | "end" | "before" | "after";
+            position: "end" | "start" | "before" | "after";
             targetId?: string | undefined;
         };
         output: {
             id: string;
+            classId: string;
             name: string;
             color: string | null;
-            classId: string;
             order: number | null;
         } | null;
         meta: object;
     }>;
     update: import("@trpc/server").TRPCMutationProcedure<{
         input: {
+            [x: string]: unknown;
+            classId: string;
             id: string;
             name: string;
-            classId: string;
             color?: string | undefined;
         };
         output: {
             id: string;
+            classId: string;
             name: string;
             color: string | null;
-            classId: string;
             order: number | null;
         };
         meta: object;
     }>;
     reOrder: import("@trpc/server").TRPCMutationProcedure<{
         input: {
-            id: string;
+            [x: string]: unknown;
             classId: string;
+            id: string;
             order: number;
         };
         output: {
@@ -76,8 +90,9 @@ export declare const sectionRouter: import("@trpc/server").TRPCBuiltRouter<{
     }>;
     delete: import("@trpc/server").TRPCMutationProcedure<{
         input: {
-            id: string;
+            [x: string]: unknown;
             classId: string;
+            id: string;
         };
         output: {
             id: string;

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

@@ -1 +1 @@
-{"version":3,"file":"section.d.ts","sourceRoot":"","sources":["../../src/routers/section.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAuBxB,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkUxB,CAAC"}
+{"version":3,"file":"section.d.ts","sourceRoot":"/","sources":["routers/section.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAkCxB,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CxB,CAAC"}

package/dist/routers/section.js

@@ -1,9 +1,11 @@
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="d31ac70e-8c0c-5d80-9d4e-e996c6dc6b08")}catch(e){}}();
 import { z } from "zod";
-import { createTRPCRouter, protectedProcedure } from "../trpc.js";
-import { TRPCError } from "@trpc/server";
-import { prisma } from "../lib/prisma.js";
+import { createTRPCRouter, protectedClassMemberProcedure, protectedTeacherProcedure, } from "../trpc.js";
+import { sectionExists, createSectionRecord, reorderSection, updateSectionRecord, reOrderSection, deleteSectionRecord, } from "../services/section.js";
 const createSectionSchema = z.object({
     classId: z.string(),
+    id: z.string().optional(),
     name: z.string(),
     color: z.string().optional(),
 });
@@ -18,285 +20,33 @@ const deleteSectionSchema = z.object({
     classId: z.string(),
 });
 export const sectionRouter = createTRPCRouter({
-    create: protectedProcedure
+    exists: protectedClassMemberProcedure
+        .input(z.object({ id: z.string() }))
+        .query(({ input }) => sectionExists(input.id)),
+    create: protectedTeacherProcedure
         .input(createSectionSchema)
-        .mutation(async ({ ctx, input }) => {
-        if (!ctx.user) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "User must be authenticated",
-            });
-        }
-        // Verify user is a teacher of the class
-        const classData = await prisma.class.findFirst({
-            where: {
-                id: input.classId,
-                teachers: {
-                    some: {
-                        id: ctx.user.id,
-                    },
-                },
-            },
-        });
-        if (!classData) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Class not found or you are not a teacher",
-            });
-        }
-        const section = await prisma.section.create({
-            data: {
-                name: input.name,
-                order: 0,
-                class: {
-                    connect: { id: input.classId },
-                },
-                ...(input.color && {
-                    color: input.color,
-                }),
-            },
-        });
-        // Insert new section at top of unified list (sections + assignments) and normalize
-        const [sections, assignments] = await Promise.all([
-            prisma.section.findMany({
-                where: { classId: input.classId },
-                select: { id: true, order: true },
-            }),
-            prisma.assignment.findMany({
-                where: { classId: input.classId },
-                select: { id: true, order: true },
-            }),
-        ]);
-        const unified = [
-            ...sections.map(s => ({ id: s.id, order: s.order, type: 'section' })),
-            ...assignments.map(a => ({ id: a.id, order: a.order, type: 'assignment' })),
-        ].sort((a, b) => (a.order ?? Number.MAX_SAFE_INTEGER) - (b.order ?? Number.MAX_SAFE_INTEGER));
-        const withoutNew = unified.filter(item => !(item.id === section.id && item.type === 'section'));
-        const reindexed = [{ id: section.id, type: 'section' }, ...withoutNew.map(item => ({ id: item.id, type: item.type }))];
-        await Promise.all(reindexed.map((item, index) => {
-            if (item.type === 'section') {
-                return prisma.section.update({ where: { id: item.id }, data: { order: index + 1 } });
-            }
-            else {
-                return prisma.assignment.update({ where: { id: item.id }, data: { order: index + 1 } });
-            }
-        }));
-        return section;
-    }),
-    reorder: protectedProcedure
+        .mutation(({ ctx, input }) => createSectionRecord(ctx.user.id, input)),
+    reorder: protectedTeacherProcedure
         .input(z.object({
         classId: z.string(),
-        movedId: z.string(), // Section ID
-        // One of: place at start/end of unified list, or relative to targetId (can be section or assignment)
-        position: z.enum(['start', 'end', 'before', 'after']),
-        targetId: z.string().optional(), // Can be a section ID or assignment ID
+        movedId: z.string(),
+        position: z.enum(["start", "end", "before", "after"]),
+        targetId: z.string().optional(),
     }))
-        .mutation(async ({ ctx, input }) => {
-        if (!ctx.user) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "User must be authenticated",
-            });
-        }
-        const { classId, movedId, position, targetId } = input;
-        const moved = await prisma.section.findFirst({
-            where: { id: movedId, classId },
-            select: { id: true, classId: true },
-        });
-        if (!moved) {
-            throw new TRPCError({ code: 'NOT_FOUND', message: 'Section not found' });
-        }
-        if ((position === 'before' || position === 'after') && !targetId) {
-            throw new TRPCError({ code: 'BAD_REQUEST', message: 'targetId required for before/after' });
-        }
-        const result = await prisma.$transaction(async (tx) => {
-            const [sections, assignments] = await Promise.all([
-                tx.section.findMany({
-                    where: { classId },
-                    select: { id: true, order: true },
-                }),
-                tx.assignment.findMany({
-                    where: { classId },
-                    select: { id: true, order: true },
-                }),
-            ]);
-            const unified = [
-                ...sections.map(s => ({ id: s.id, order: s.order, type: 'section' })),
-                ...assignments.map(a => ({ id: a.id, order: a.order, type: 'assignment' })),
-            ].sort((a, b) => (a.order ?? Number.MAX_SAFE_INTEGER) - (b.order ?? Number.MAX_SAFE_INTEGER));
-            const movedIdx = unified.findIndex(item => item.id === movedId && item.type === 'section');
-            if (movedIdx === -1) {
-                throw new TRPCError({ code: 'NOT_FOUND', message: 'Section not found in unified list' });
-            }
-            const withoutMoved = unified.filter(item => !(item.id === movedId && item.type === 'section'));
-            let next = [];
-            if (position === 'start') {
-                next = [{ id: movedId, type: 'section' }, ...withoutMoved.map(item => ({ id: item.id, type: item.type }))];
-            }
-            else if (position === 'end') {
-                next = [...withoutMoved.map(item => ({ id: item.id, type: item.type })), { id: movedId, type: 'section' }];
-            }
-            else {
-                const targetIdx = withoutMoved.findIndex(item => item.id === targetId);
-                if (targetIdx === -1) {
-                    throw new TRPCError({ code: 'BAD_REQUEST', message: 'targetId not found in unified list' });
-                }
-                if (position === 'before') {
-                    next = [
-                        ...withoutMoved.slice(0, targetIdx).map(item => ({ id: item.id, type: item.type })),
-                        { id: movedId, type: 'section' },
-                        ...withoutMoved.slice(targetIdx).map(item => ({ id: item.id, type: item.type })),
-                    ];
-                }
-                else {
-                    next = [
-                        ...withoutMoved.slice(0, targetIdx + 1).map(item => ({ id: item.id, type: item.type })),
-                        { id: movedId, type: 'section' },
-                        ...withoutMoved.slice(targetIdx + 1).map(item => ({ id: item.id, type: item.type })),
-                    ];
-                }
-            }
-            // Normalize to 1..n
-            await Promise.all(next.map((item, index) => {
-                if (item.type === 'section') {
-                    return tx.section.update({ where: { id: item.id }, data: { order: index + 1 } });
-                }
-                else {
-                    return tx.assignment.update({ where: { id: item.id }, data: { order: index + 1 } });
-                }
-            }));
-            return tx.section.findUnique({ where: { id: movedId } });
-        });
-        return result;
-    }),
-    update: protectedProcedure
+        .mutation(({ ctx, input }) => reorderSection(ctx.user.id, input)),
+    update: protectedTeacherProcedure
         .input(updateSectionSchema)
-        .mutation(async ({ ctx, input }) => {
-        if (!ctx.user) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "User must be authenticated",
-            });
-        }
-        // Verify user is a teacher of the class
-        const classData = await prisma.class.findFirst({
-            where: {
-                id: input.classId,
-                teachers: {
-                    some: {
-                        id: ctx.user.id,
-                    },
-                },
-            },
-        });
-        if (!classData) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Class not found or you are not a teacher",
-            });
-        }
-        const section = await prisma.section.update({
-            where: { id: input.id },
-            data: {
-                name: input.name,
-                ...(input.color && {
-                    color: input.color,
-                }),
-            },
-        });
-        return section;
-    }),
-    reOrder: protectedProcedure
+        .mutation(({ ctx, input }) => updateSectionRecord(ctx.user.id, input)),
+    reOrder: protectedTeacherProcedure
         .input(z.object({
         id: z.string(),
         classId: z.string(),
         order: z.number(),
     }))
-        .mutation(async ({ ctx, input }) => {
-        if (!ctx.user) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "User must be authenticated",
-            });
-        }
-        // Verify user is a teacher of the class
-        const classData = await prisma.class.findFirst({
-            where: {
-                id: input.classId,
-                teachers: {
-                    some: {
-                        id: ctx.user.id,
-                    },
-                },
-            },
-        });
-        if (!classData) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Class not found or you are not a teacher",
-            });
-        }
-        // Update order and normalize unified list
-        await prisma.$transaction(async (tx) => {
-            await tx.section.update({
-                where: { id: input.id },
-                data: { order: input.order },
-            });
-            // Normalize entire unified list
-            const [sections, assignments] = await Promise.all([
-                tx.section.findMany({
-                    where: { classId: input.classId },
-                    select: { id: true, order: true },
-                }),
-                tx.assignment.findMany({
-                    where: { classId: input.classId },
-                    select: { id: true, order: true },
-                }),
-            ]);
-            const unified = [
-                ...sections.map(s => ({ id: s.id, order: s.order, type: 'section' })),
-                ...assignments.map(a => ({ id: a.id, order: a.order, type: 'assignment' })),
-            ].sort((a, b) => (a.order ?? Number.MAX_SAFE_INTEGER) - (b.order ?? Number.MAX_SAFE_INTEGER));
-            await Promise.all(unified.map((item, index) => {
-                if (item.type === 'section') {
-                    return tx.section.update({ where: { id: item.id }, data: { order: index + 1 } });
-                }
-                else {
-                    return tx.assignment.update({ where: { id: item.id }, data: { order: index + 1 } });
-                }
-            }));
-        });
-        return { id: input.id };
-    }),
-    delete: protectedProcedure
+        .mutation(({ ctx, input }) => reOrderSection(ctx.user.id, input)),
+    delete: protectedTeacherProcedure
         .input(deleteSectionSchema)
-        .mutation(async ({ ctx, input }) => {
-        if (!ctx.user) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "User must be authenticated",
-            });
-        }
-        // Verify user is a teacher of the class
-        const classData = await prisma.class.findFirst({
-            where: {
-                id: input.classId,
-                teachers: {
-                    some: {
-                        id: ctx.user.id,
-                    },
-                },
-            },
-        });
-        if (!classData) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Class not found or you are not a teacher",
-            });
-        }
-        await prisma.section.delete({
-            where: { id: input.id },
-        });
-        return { id: input.id };
-    }),
+        .mutation(({ ctx, input }) => deleteSectionRecord(ctx.user.id, input)),
 });
+//# sourceMappingURL=section.js.map
+//# debugId=d31ac70e-8c0c-5d80-9d4e-e996c6dc6b08

package/dist/routers/section.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"section.js","sources":["routers/section.ts"],"sourceRoot":"/","sourcesContent":["import { z } from \"zod\";\nimport {\n  createTRPCRouter,\n  protectedClassMemberProcedure,\n  protectedTeacherProcedure,\n} from \"../trpc.js\";\nimport {\n  sectionExists,\n  createSectionRecord,\n  reorderSection,\n  updateSectionRecord,\n  reOrderSection,\n  deleteSectionRecord,\n} from \"../services/section.js\";\n\nconst createSectionSchema = z.object({\n  classId: z.string(),\n  id: z.string().optional(),\n  name: z.string(),\n  color: z.string().optional(),\n});\n\nconst updateSectionSchema = z.object({\n  id: z.string(),\n  classId: z.string(),\n  name: z.string(),\n  color: z.string().optional(),\n});\n\nconst deleteSectionSchema = z.object({\n  id: z.string(),\n  classId: z.string(),\n});\n\nexport const sectionRouter = createTRPCRouter({\n  exists: protectedClassMemberProcedure\n    .input(z.object({ id: z.string() }))\n    .query(({ input }) => sectionExists(input.id)),\n\n  create: protectedTeacherProcedure\n    .input(createSectionSchema)\n    .mutation(({ ctx, input }) =>\n      createSectionRecord(ctx.user!.id, input)\n    ),\n\n  reorder: protectedTeacherProcedure\n    .input(\n      z.object({\n        classId: z.string(),\n        movedId: z.string(),\n        position: z.enum([\"start\", \"end\", \"before\", \"after\"]),\n        targetId: z.string().optional(),\n      })\n    )\n    .mutation(({ ctx, input }) =>\n      reorderSection(ctx.user!.id, input)\n    ),\n\n  update: protectedTeacherProcedure\n    .input(updateSectionSchema)\n    .mutation(({ ctx, input }) =>\n      updateSectionRecord(ctx.user!.id, input)\n    ),\n\n  reOrder: protectedTeacherProcedure\n    .input(\n      z.object({\n        id: z.string(),\n        classId: z.string(),\n        order: z.number(),\n      })\n    )\n    .mutation(({ ctx, input }) =>\n      reOrderSection(ctx.user!.id, input)\n    ),\n\n  delete: protectedTeacherProcedure\n    .input(deleteSectionSchema)\n    .mutation(({ ctx, input }) =>\n      deleteSectionRecord(ctx.user!.id, input)\n    ),\n});\n"],"names":[],"mappings":"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","debug_id":"d31ac70e-8c0c-5d80-9d4e-e996c6dc6b08"}

package/dist/routers/user.d.ts

@@ -35,9 +35,9 @@ export declare const userRouter: import("@trpc/server").TRPCBuiltRouter<{
     updateProfile: import("@trpc/server").TRPCMutationProcedure<{
         input: {
             profile?: {
-                location?: string | null | undefined;
                 displayName?: string | null | undefined;
                 bio?: string | null | undefined;
+                location?: string | null | undefined;
                 website?: string | null | undefined;
             } | undefined;
             profilePicture?: {

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

@@ -1 +1 @@
-{"version":3,"file":"user.d.ts","sourceRoot":"","sources":["../../src/routers/user.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA2DxB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuMrB,CAAC"}
+{"version":3,"file":"user.d.ts","sourceRoot":"/","sources":["routers/user.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAiExB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgBrB,CAAC"}