@studious-lms/server 1.11.0 → 1.13.0

package/src/routers/_app.ts

@@ -26,6 +26,8 @@ import { schoolRouter } from "./school.js";
 import { departmentRouter } from "./department.js";
 import { tagRouter } from "./tag.js";
 import { permissionsRouter } from "./permissions.js";
+import { discussionRouter } from "./discussion.js";
+import { adminRouter } from "./admin.js";
 
 export const appRouter = createTRPCRouter({
   class: classRouter,
@@ -53,6 +55,8 @@ export const appRouter = createTRPCRouter({
   department: departmentRouter,
   tag: tagRouter,
   permissions: permissionsRouter,
+  discussion: discussionRouter,
+  admin: adminRouter,
 });
 
 // Export type router type definition

package/src/routers/admin.ts

@@ -0,0 +1,70 @@
+import { z } from 'zod';
+import { RunJobStatus, RunJobType } from '@prisma/client';
+import { createTRPCRouter, adminProcedure } from '../trpc.js';
+import {
+  getRunJobForAdmin,
+  listRunJobsForAdmin,
+} from '../services/adminRunJob.js';
+import {
+  listDepartmentsForAdmin,
+  listEarlyAccessRequestsForAdmin,
+  listSchoolDevelopmentProgramsForAdmin,
+  listSchoolsForAdmin,
+} from '../services/adminInstitution.js';
+
+export const adminRouter = createTRPCRouter({
+  listRunJobs: adminProcedure
+    .input(
+      z.object({
+        page: z.number().int().min(0).default(0),
+        pageSize: z.number().int().min(1).max(100).default(25),
+        status: z.nativeEnum(RunJobStatus).optional(),
+        type: z.nativeEnum(RunJobType).optional(),
+      }),
+    )
+    .query(({ input }) => listRunJobsForAdmin(input)),
+
+  getRunJob: adminProcedure
+    .input(z.object({ id: z.string().uuid() }))
+    .query(({ input }) => getRunJobForAdmin(input.id)),
+
+  listSchools: adminProcedure
+    .input(
+      z.object({
+        page: z.number().int().min(0).default(0),
+        pageSize: z.number().int().min(1).max(100).default(25),
+        query: z.string().optional(),
+      }),
+    )
+    .query(({ input }) => listSchoolsForAdmin(input)),
+
+  listDepartments: adminProcedure
+    .input(
+      z.object({
+        page: z.number().int().min(0).default(0),
+        pageSize: z.number().int().min(1).max(100).default(25),
+        schoolId: z.string().uuid().optional(),
+      }),
+    )
+    .query(({ input }) => listDepartmentsForAdmin(input)),
+
+  listSchoolDevelopmentPrograms: adminProcedure
+      .input(
+        z.object({
+          page: z.number().int().min(0).default(0),
+          pageSize: z.number().int().min(1).max(100).default(25),
+          status: z.string().optional(),
+          query: z.string().optional(),
+        }),
+      )
+      .query(({ input }) => listSchoolDevelopmentProgramsForAdmin(input)),
+
+  listEarlyAccessRequests: adminProcedure
+    .input(
+      z.object({
+        page: z.number().int().min(0).default(0),
+        pageSize: z.number().int().min(1).max(100).default(25),
+      }),
+    )
+    .query(({ input }) => listEarlyAccessRequestsForAdmin(input)),
+});

package/src/routers/announcement.ts

@@ -453,9 +453,10 @@ export const announcementRouter = createTRPCRouter({
                         },
                     },
                 },
-                orderBy: {
-                    createdAt: 'asc',
-                },
+                orderBy: [
+                    { isPinned: 'desc' as const },
+                    { createdAt: 'asc' as const },
+                ],
             });
 
             return { comments };

package/src/routers/assignment.ts

@@ -366,7 +366,7 @@ export const assignmentRouter = createTRPCRouter({
           parentCommentId: null,
         },
         include: commentInclude,
-        orderBy: { createdAt: "asc" },
+        orderBy: [{ isPinned: "desc" }, { createdAt: "asc" }],
       });
 
       return { comments };
@@ -476,7 +476,7 @@ export const assignmentRouter = createTRPCRouter({
           parentCommentId: null,
         },
         include: commentInclude,
-        orderBy: { createdAt: "asc" },
+        orderBy: [{ isPinned: "desc" }, { createdAt: "asc" }],
       });
 
       return { comments };

package/src/routers/class.ts

@@ -60,6 +60,9 @@ export const classRouter = createTRPCRouter({
         subject: z.string().optional(),
         color: z.string().optional(),
         departmentId: z.string().nullable().optional(),
+        discussionsEnabled: z.boolean().optional(),
+        studentsCanCreateDiscussions: z.boolean().optional(),
+        studentsCanReply: z.boolean().optional(),
       })
     )
     .mutation(({ input }) => {

package/src/routers/comment.ts

@@ -7,6 +7,7 @@ import {
   replyToComment,
   updateComment,
   deleteComment,
+  pinComment,
   addReaction,
   removeReaction,
   getReactions,
@@ -49,6 +50,10 @@ export const commentRouter = createTRPCRouter({
     .input(z.object({ id: z.string() }))
     .mutation(({ ctx, input }) => deleteComment(ctx.user!.id, input.id)),
 
+  pin: protectedProcedure
+    .input(z.object({ id: z.string(), isPinned: z.boolean() }))
+    .mutation(({ ctx, input }) => pinComment(ctx.user!.id, input.id, input.isPinned)),
+
   addReaction: protectedProcedure
     .input(
       z.object({

package/src/routers/discussion.ts

@@ -0,0 +1,205 @@
+import { z } from "zod";
+import { createTRPCRouter, protectedProcedure } from "../trpc.js";
+import {
+  createDiscussion,
+  createDiscussionTag,
+  deleteDiscussion,
+  deleteDiscussionReply,
+  deleteDiscussionTag,
+  getDiscussionClassAccess,
+  getDiscussion,
+  getUnreadCounts,
+  listDiscussionTags,
+  listDiscussions,
+  lockDiscussion,
+  markAcceptedAnswer,
+  markDiscussionRead,
+  pinDiscussion,
+  replyToDiscussion,
+  toggleDiscussionReaction,
+  updateDiscussion,
+  updateDiscussionReply,
+  updateDiscussionTag,
+} from "../services/discussion.js";
+import { confirmDirectUpload, createDirectUploadFiles } from "../lib/fileUpload.js";
+import { prisma } from "../lib/prisma.js";
+import { TRPCError } from "@trpc/server";
+
+const discussionTypeSchema = z.enum(["DISCUSSION", "QUESTION", "ANNOUNCEMENT"]);
+const reactionTypeSchema = z.enum(["THUMBSUP", "CELEBRATE", "CARE", "HEART", "IDEA", "HAPPY"]);
+const hexColorSchema = z.string().regex(/^#[0-9A-Fa-f]{6}$/);
+const MAX_DISCUSSION_UPLOAD_FILES = 20;
+const MAX_DISCUSSION_FILE_BYTES = 25 * 1024 * 1024;
+const reactionToggleInputSchema = z
+  .object({
+    discussionId: z.string().optional(),
+    discussionReplyId: z.string().optional(),
+    type: reactionTypeSchema,
+  })
+  .refine(
+    ({ discussionId, discussionReplyId }) => Boolean(discussionId) !== Boolean(discussionReplyId),
+    { message: "must provide exactly one of discussionId or discussionReplyId" }
+  );
+const directFileSchema = z.object({
+  name: z.string().trim().min(1).max(255),
+  type: z.string().trim().min(1).max(127),
+  size: z.number().int().nonnegative().max(MAX_DISCUSSION_FILE_BYTES),
+});
+
+export const discussionRouter = createTRPCRouter({
+  list: protectedProcedure
+    .input(
+      z.object({
+        classId: z.string(),
+        tagId: z.string().optional(),
+        type: discussionTypeSchema.optional(),
+        search: z.string().optional(),
+        sort: z.enum(["recent", "activity", "top"]).default("activity"),
+        cursor: z.string().optional(),
+        limit: z.number().min(1).max(50).default(20),
+      })
+    )
+    .query(({ ctx, input }) => listDiscussions(ctx.user!.id, input)),
+
+  get: protectedProcedure
+    .input(z.object({ discussionId: z.string() }))
+    .query(({ ctx, input }) => getDiscussion(ctx.user!.id, input.discussionId)),
+
+  create: protectedProcedure
+    .input(
+      z.object({
+        classId: z.string(),
+        title: z.string().trim().min(1).max(160),
+        body: z.string().trim().min(1),
+        type: discussionTypeSchema.default("DISCUSSION"),
+        tagIds: z.array(z.string()).optional(),
+        attachmentIds: z.array(z.string()).optional(),
+      })
+    )
+    .mutation(({ ctx, input }) => createDiscussion(ctx.user!.id, input)),
+
+  getUploadUrls: protectedProcedure
+    .input(
+      z.object({
+        classId: z.string(),
+        files: z.array(directFileSchema).min(1).max(MAX_DISCUSSION_UPLOAD_FILES),
+      })
+    )
+    .mutation(async ({ ctx, input }) => {
+      await getDiscussionClassAccess(input.classId, ctx.user!.id);
+      return {
+        uploadFiles: await createDirectUploadFiles(input.files, ctx.user!.id),
+      };
+    }),
+
+  confirmUpload: protectedProcedure
+    .input(
+      z.object({
+        fileId: z.string(),
+        uploadSuccess: z.boolean(),
+        errorMessage: z.string().optional(),
+      })
+    )
+    .mutation(async ({ ctx, input }) => {
+      const file = await prisma.file.findFirst({
+        where: {
+          id: input.fileId,
+          userId: ctx.user!.id,
+          discussionId: null,
+          discussionReplyId: null,
+        },
+        select: { id: true },
+      });
+      if (!file) {
+        throw new TRPCError({ code: "NOT_FOUND", message: "File not found or you do not have permission" });
+      }
+      await confirmDirectUpload(input.fileId, input.uploadSuccess, input.errorMessage);
+      return { success: true };
+    }),
+
+  update: protectedProcedure
+    .input(
+      z.object({
+        discussionId: z.string(),
+        title: z.string().trim().min(1).max(160).optional(),
+        body: z.string().trim().min(1).optional(),
+        type: discussionTypeSchema.optional(),
+        tagIds: z.array(z.string()).optional(),
+        allowReplies: z.boolean().optional(),
+      })
+    )
+    .mutation(({ ctx, input }) => updateDiscussion(ctx.user!.id, input)),
+
+  delete: protectedProcedure
+    .input(z.object({ discussionId: z.string() }))
+    .mutation(({ ctx, input }) => deleteDiscussion(ctx.user!.id, input.discussionId)),
+
+  reply: protectedProcedure
+    .input(
+      z.object({
+        discussionId: z.string(),
+        parentReplyId: z.string().optional(),
+        body: z.string().trim().min(1),
+        attachmentIds: z.array(z.string()).optional(),
+      })
+    )
+    .mutation(({ ctx, input }) => replyToDiscussion(ctx.user!.id, input)),
+
+  updateReply: protectedProcedure
+    .input(
+      z.object({
+        replyId: z.string(),
+        body: z.string().trim().min(1),
+        attachmentIds: z.array(z.string()).optional(),
+      })
+    )
+    .mutation(({ ctx, input }) => updateDiscussionReply(ctx.user!.id, input)),
+
+  deleteReply: protectedProcedure
+    .input(z.object({ replyId: z.string() }))
+    .mutation(({ ctx, input }) => deleteDiscussionReply(ctx.user!.id, input.replyId)),
+
+  pin: protectedProcedure
+    .input(z.object({ discussionId: z.string(), isPinned: z.boolean() }))
+    .mutation(({ ctx, input }) => pinDiscussion(ctx.user!.id, input.discussionId, input.isPinned)),
+
+  lock: protectedProcedure
+    .input(z.object({ discussionId: z.string(), isLocked: z.boolean() }))
+    .mutation(({ ctx, input }) => lockDiscussion(ctx.user!.id, input.discussionId, input.isLocked)),
+
+  markAcceptedAnswer: protectedProcedure
+    .input(z.object({ replyId: z.string(), accepted: z.boolean() }))
+    .mutation(({ ctx, input }) => markAcceptedAnswer(ctx.user!.id, input.replyId, input.accepted)),
+
+  markRead: protectedProcedure
+    .input(z.object({ discussionId: z.string() }))
+    .mutation(({ ctx, input }) => markDiscussionRead(ctx.user!.id, input.discussionId)),
+
+  getUnreadCounts: protectedProcedure
+    .input(z.object({ classIds: z.array(z.string()).max(100) }))
+    .query(({ ctx, input }) => getUnreadCounts(ctx.user!.id, input.classIds)),
+
+  reactions: createTRPCRouter({
+    toggle: protectedProcedure
+      .input(reactionToggleInputSchema)
+      .mutation(({ ctx, input }) => toggleDiscussionReaction(ctx.user!.id, input)),
+  }),
+
+  tags: createTRPCRouter({
+    list: protectedProcedure
+      .input(z.object({ classId: z.string() }))
+      .query(({ ctx, input }) => listDiscussionTags(ctx.user!.id, input.classId)),
+
+    create: protectedProcedure
+      .input(z.object({ classId: z.string(), name: z.string().trim().min(1).max(32), color: hexColorSchema }))
+      .mutation(({ ctx, input }) => createDiscussionTag(ctx.user!.id, input)),
+
+    update: protectedProcedure
+      .input(z.object({ tagId: z.string(), name: z.string().trim().min(1).max(32).optional(), color: hexColorSchema.optional() }))
+      .mutation(({ ctx, input }) => updateDiscussionTag(ctx.user!.id, input)),
+
+    delete: protectedProcedure
+      .input(z.object({ tagId: z.string() }))
+      .mutation(({ ctx, input }) => deleteDiscussionTag(ctx.user!.id, input.tagId)),
+  }),
+});

package/src/routers/worksheet.ts

@@ -233,6 +233,7 @@ export const worksheetRouter = createTRPCRouter({
           "MATH_EXPRESSION",
           "ESSAY",
         ]),
+        order: z.number().int().min(0).optional(),
       })
     )
     .mutation(({ ctx, input }) =>
@@ -243,6 +244,7 @@ export const worksheetRouter = createTRPCRouter({
         options: input.options,
         markScheme: input.markScheme,
         type: input.type,
+        order: input.order,
       })
     ),