@studious-lms/server 1.25.0 → 1.26.0

package/src/models/module.ts

@@ -0,0 +1,77 @@
+/**
+ * Module model – Canvas-style class modules, items and student progress.
+ */
+import { prisma } from "../lib/prisma.js";
+import { classTeacherOrSchoolAdminWhere } from "./access.js";
+
+/** @returns Class if user is a teacher or school admin. */
+export function findClassWithTeacher(classId: string, teacherId: string) {
+  return prisma.class.findFirst({
+    where: {
+      id: classId,
+      ...classTeacherOrSchoolAdminWhere(teacherId),
+    },
+  });
+}
+
+export const moduleInclude = {
+  items: {
+    orderBy: { position: "asc" as const },
+  },
+  prerequisites: {
+    select: { prerequisiteId: true },
+  },
+} as const;
+
+/** @returns All modules of a class ordered by position. */
+export function findModulesByClassId(classId: string, publishedOnly = false) {
+  return prisma.module.findMany({
+    where: { classId, ...(publishedOnly && { published: true }) },
+    orderBy: { position: "asc" },
+    include: moduleInclude,
+  });
+}
+
+/** @returns Module by ID scoped to a class. */
+export function findModuleByClassAndId(id: string, classId: string) {
+  return prisma.module.findFirst({
+    where: { id, classId },
+    include: moduleInclude,
+  });
+}
+
+/** @returns Module item with its module, scoped to a class. */
+export function findModuleItemInClass(itemId: string, classId: string) {
+  return prisma.courseModuleItem.findFirst({
+    where: { id: itemId, module: { classId } },
+    include: { module: true },
+  });
+}
+
+/** @returns Progress rows of a student for all items of a class. */
+export function findStudentProgressForClass(classId: string, studentId: string) {
+  return prisma.moduleItemProgress.findMany({
+    where: { studentId, moduleItem: { module: { classId } } },
+  });
+}
+
+/** Upsert a progress row for a student and item. */
+export function upsertItemProgress(
+  moduleItemId: string,
+  studentId: string,
+  status: "INCOMPLETE" | "COMPLETE"
+) {
+  return prisma.moduleItemProgress.upsert({
+    where: { moduleItemId_studentId: { moduleItemId, studentId } },
+    create: {
+      moduleItemId,
+      studentId,
+      status,
+      ...(status === "COMPLETE" && { completedAt: new Date() }),
+    },
+    update:
+      status === "COMPLETE"
+        ? { status, completedAt: new Date() }
+        : {},
+  });
+}

package/src/pipelines/gradeWorksheet.ts

@@ -9,6 +9,7 @@ import z from "zod";
 import { inference } from "../utils/inference.js";
 import { getAIUserId } from "../utils/aiUser.js";
 import { pusher, worksheetChannel } from "../lib/pusher.js";
+import { syncWorksheetModuleProgress } from "../services/module.js";
 
 
 const removeAllPreviousAIComments = async (worksheetQuestionProgressId: string) => {
@@ -369,6 +370,11 @@ export const gradeWorksheetPipeline = async (
         }
 
     };
+
+    await syncWorksheetModuleProgress(
+        worksheetResponse.studentId,
+        worksheetResponse.worksheetId,
+    );
 };
 
 export const cancelGradePipeline = async (worksheetResponseId: string, worksheetQuestionProgressId: string) => {

package/src/routers/_app.ts

@@ -29,6 +29,7 @@ import { permissionsRouter } from "./permissions.js";
 import { discussionRouter } from "./discussion.js";
 import { adminRouter } from "./admin.js";
 import { embeddingRouter } from "./embedding.js";
+import { moduleRouter } from "./module.js";
 import { gradebookRouter } from "./gradebook.js";
 import { feesRouter } from "./fees.js";
 import { marketplaceRouter } from "./marketplace.js";
@@ -65,6 +66,7 @@ export const appRouter = createTRPCRouter({
   discussion: discussionRouter,
   admin: adminRouter,
   embedding: embeddingRouter,
+  module: moduleRouter,
   gradebook: gradebookRouter,
   fees: feesRouter,
   marketplace: marketplaceRouter,

package/src/routers/marketplace.ts

@@ -15,6 +15,7 @@ import {
   publishWorksheetListing,
   reportMarketplaceListing,
   unpublishMarketplaceListing,
+  updateMarketplaceListingDetails,
 } from "../services/marketplace.js";
 
 const listingTypeSchema = z.enum(["MARKSCHEME", "WORKSHEET", "FILE"]);
@@ -109,6 +110,21 @@ export const marketplaceRouter = createTRPCRouter({
       importMarketplaceListing(ctx.user!.id, input)
     ),
 
+  /** Edit listing metadata (author or school admin). */
+  update: protectedProcedure
+    .input(
+      z.object({
+        listingId: z.string(),
+        title: z.string().trim().min(1).max(160).optional(),
+        description: z.string().trim().max(2000).nullable().optional(),
+        visibility: visibilitySchema.optional(),
+        tags: tagsSchema,
+      })
+    )
+    .mutation(({ ctx, input }) =>
+      updateMarketplaceListingDetails(ctx.user!.id, input)
+    ),
+
   report: protectedProcedure
     .input(z.object({ listingId: z.string() }))
     .mutation(({ ctx, input }) =>

package/src/routers/module.ts

@@ -0,0 +1,118 @@
+import { z } from "zod";
+import { CourseModuleItemType as ModuleItemType, ModuleItemRequirementType } from "@prisma/client";
+import {
+  createTRPCRouter,
+  protectedClassMemberProcedure,
+  protectedTeacherProcedure,
+} from "../trpc.js";
+import {
+  listModulesRecord,
+  createModuleRecord,
+  updateModuleRecord,
+  deleteModuleRecord,
+  reorderModulesRecord,
+  createModuleItemRecord,
+  updateModuleItemRecord,
+  deleteModuleItemRecord,
+  reorderModuleItemsRecord,
+  getStudentModulesState,
+  markItemViewedRecord,
+} from "../services/module.js";
+
+const itemTypeSchema = z.nativeEnum(ModuleItemType);
+const requirementTypeSchema = z.nativeEnum(ModuleItemRequirementType);
+
+export const moduleRouter = createTRPCRouter({
+  /** Teacher view: every module (published or not) with its items. */
+  list: protectedTeacherProcedure
+    .input(z.object({ classId: z.string() }))
+    .query(({ ctx, input }) => listModulesRecord(ctx.user!.id, input.classId)),
+
+  /** Student view: published modules with lock state and progress. */
+  getStudentState: protectedClassMemberProcedure
+    .input(z.object({ classId: z.string() }))
+    .query(({ ctx, input }) =>
+      getStudentModulesState(input.classId, ctx.user!.id)
+    ),
+
+  create: protectedTeacherProcedure
+    .input(
+      z.object({
+        classId: z.string(),
+        title: z.string().min(1),
+        unlockAt: z.coerce.date().nullish(),
+        requireSequential: z.boolean().optional(),
+      })
+    )
+    .mutation(({ ctx, input }) => createModuleRecord(ctx.user!.id, input)),
+
+  update: protectedTeacherProcedure
+    .input(
+      z.object({
+        classId: z.string(),
+        id: z.string(),
+        title: z.string().min(1).optional(),
+        unlockAt: z.coerce.date().nullable().optional(),
+        requireSequential: z.boolean().optional(),
+        published: z.boolean().optional(),
+        prerequisiteIds: z.array(z.string()).optional(),
+      })
+    )
+    .mutation(({ ctx, input }) => updateModuleRecord(ctx.user!.id, input)),
+
+  delete: protectedTeacherProcedure
+    .input(z.object({ classId: z.string(), id: z.string() }))
+    .mutation(({ ctx, input }) => deleteModuleRecord(ctx.user!.id, input)),
+
+  reorder: protectedTeacherProcedure
+    .input(z.object({ classId: z.string(), orderedIds: z.array(z.string()) }))
+    .mutation(({ ctx, input }) => reorderModulesRecord(ctx.user!.id, input)),
+
+  createItem: protectedTeacherProcedure
+    .input(
+      z.object({
+        classId: z.string(),
+        moduleId: z.string(),
+        itemType: itemTypeSchema,
+        itemId: z.string().optional(),
+        externalUrl: z.string().url().optional(),
+        title: z.string().optional(),
+        indent: z.number().int().min(0).max(4).optional(),
+        requirementType: requirementTypeSchema.optional(),
+        requiredScore: z.number().min(0).optional(),
+      })
+    )
+    .mutation(({ ctx, input }) => createModuleItemRecord(ctx.user!.id, input)),
+
+  updateItem: protectedTeacherProcedure
+    .input(
+      z.object({
+        classId: z.string(),
+        id: z.string(),
+        title: z.string().nullable().optional(),
+        externalUrl: z.string().url().optional(),
+        indent: z.number().int().min(0).max(4).optional(),
+        requirementType: requirementTypeSchema.nullable().optional(),
+        requiredScore: z.number().min(0).nullable().optional(),
+      })
+    )
+    .mutation(({ ctx, input }) => updateModuleItemRecord(ctx.user!.id, input)),
+
+  deleteItem: protectedTeacherProcedure
+    .input(z.object({ classId: z.string(), id: z.string() }))
+    .mutation(({ ctx, input }) => deleteModuleItemRecord(ctx.user!.id, input)),
+
+  reorderItems: protectedTeacherProcedure
+    .input(
+      z.object({
+        classId: z.string(),
+        items: z.array(z.object({ id: z.string(), moduleId: z.string() })),
+      })
+    )
+    .mutation(({ ctx, input }) => reorderModuleItemsRecord(ctx.user!.id, input)),
+
+  /** Record that a student viewed an item (completes VIEW requirements). */
+  markItemViewed: protectedClassMemberProcedure
+    .input(z.object({ classId: z.string(), itemId: z.string() }))
+    .mutation(({ ctx, input }) => markItemViewedRecord(ctx.user!.id, input)),
+});

package/src/services/assignment.ts

@@ -28,6 +28,7 @@ import { enqueueRunJob } from "../workers/queues.js";
 import { logger } from "../utils/logger.js";
 import { invalidateStudentProgressInferenceCache } from "./studentProgressInferenceCache.js";
 import { enqueueEmbedding } from "./embedding.js";
+import { syncAssignmentModuleProgress } from "./module.js";
 import { resolveAssignmentBehavior } from "../lib/assignmentTypeDefaults.js";
 
 export async function assignmentExists(id: string) {
@@ -803,7 +804,7 @@ export async function updateSubmissionRecord(
         }
       }
     }
-    return prisma.submission.update({
+    const updatedSubmission = await prisma.submission.update({
       where: { id: submission.id },
       data: {
         submitted: !submission.submitted,
@@ -821,6 +822,8 @@ export async function updateSubmissionRecord(
         },
       },
     });
+    await syncAssignmentModuleProgress(userId, submission.assignmentId);
+    return updatedSubmission;
   }
 
   const isLateUpdate = submission.assignment.dueDate < new Date();
@@ -1002,6 +1005,10 @@ export async function updateSubmissionAsTeacherRecord(
       data: { returned: !submission.returned },
       include: submissionTeacherInclude,
     });
+    await syncAssignmentModuleProgress(
+      submission.studentId,
+      submission.assignmentId
+    );
 
     if (updated.returned) {
       sendNotification({
@@ -1072,6 +1079,10 @@ export async function updateSubmissionAsTeacherRecord(
       submission.assignment.classId,
       submission.studentId,
     );
+    await syncAssignmentModuleProgress(
+      submission.studentId,
+      submission.assignmentId
+    );
   }
 
   // Index submission for RAG search after teacher grades/feedback

package/src/services/marketplace.ts

@@ -21,6 +21,7 @@ import {
   incrementMarketplaceReportCount,
   searchMarketplaceListings,
   setMarketplaceListingHidden,
+  updateMarketplaceListing,
 } from "../models/marketplace.js";
 import {
   findActiveSchoolAdminMembership,
@@ -659,6 +660,44 @@ export async function reportMarketplaceListing(
   return incrementMarketplaceReportCount(listingId);
 }
 
+export async function updateMarketplaceListingDetails(
+  userId: string,
+  input: {
+    listingId: string;
+    title?: string;
+    description?: string | null;
+    visibility?: "SCHOOL" | "PUBLIC";
+    tags?: string[];
+  }
+) {
+  const listing = await findMarketplaceListingById(input.listingId);
+  if (!listing) {
+    throw new TRPCError({ code: "NOT_FOUND", message: "Listing not found" });
+  }
+  const isAuthor = listing.authorId === userId;
+  const isSchoolAdmin =
+    listing.schoolId != null &&
+    Boolean(await findActiveSchoolAdminMembership(listing.schoolId, userId));
+  if (!isAuthor && !isSchoolAdmin) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "Only the author or a school admin can edit this listing",
+    });
+  }
+  if (input.visibility === "SCHOOL" && listing.schoolId == null) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "Listing has no school; it cannot use school visibility",
+    });
+  }
+  return updateMarketplaceListing(input.listingId, {
+    title: input.title,
+    description: input.description,
+    visibility: input.visibility,
+    tags: input.tags ? normalizeTags(input.tags) : undefined,
+  });
+}
+
 export async function hideMarketplaceListing(
   userId: string,
   listingId: string,