@studious-lms/server 1.24.0 → 1.26.0

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/routers/moduleItem.ts

@@ -14,10 +14,12 @@ import {
   updateModuleItemRecord,
 } from "../services/moduleItem.js";
 
+const MAX_MODULE_FILE_BYTES = 2 * 1024 * 1024 * 1024; // 2 GB (videos)
+
 const directFileSchema = z.object({
-  name: z.string(),
-  type: z.string(),
-  size: z.number(),
+  name: z.string().trim().min(1).max(255),
+  type: z.string().trim().min(1).max(255),
+  size: z.number().int().positive().max(MAX_MODULE_FILE_BYTES),
 });
 
 const moduleItemTypeSchema = z.enum(["PAGE", "FILES", "VIDEO"]);
@@ -76,7 +78,7 @@ export const moduleItemRouter = createTRPCRouter({
       z.object({
         classId: z.string(),
         sectionId: z.string(),
-        orderedIds: z.array(z.string()),
+        orderedIds: z.array(z.string()).min(1).max(500),
       })
     )
     .mutation(({ ctx, input }) => reorderModuleItems(ctx.user!.id, input)),

package/src/routers/school.ts

@@ -325,9 +325,14 @@ export const schoolRouter = createTRPCRouter({
    */
   generateTranscript: protectedProcedure
     .input(
-      transcriptPeriodSchema.extend({
-        studentId: z.string(),
-      })
+      transcriptPeriodSchema
+        .extend({
+          studentId: z.string(),
+        })
+        .refine((v) => !v.from || !v.to || v.from <= v.to, {
+          message: "from must be on or before to",
+          path: ["from"],
+        })
     )
     .mutation(({ ctx, input }) => generateTranscript(ctx.user!.id, input)),
 
@@ -337,9 +342,14 @@ export const schoolRouter = createTRPCRouter({
    */
   generateTranscripts: protectedProcedure
     .input(
-      transcriptPeriodSchema.extend({
-        studentIds: z.array(z.string()).min(1).max(50),
-      })
+      transcriptPeriodSchema
+        .extend({
+          studentIds: z.array(z.string()).min(1).max(50),
+        })
+        .refine((v) => !v.from || !v.to || v.from <= v.to, {
+          message: "from must be on or before to",
+          path: ["from"],
+        })
     )
     .mutation(({ ctx, input }) => generateTranscripts(ctx.user!.id, input)),
 

package/src/services/academicCalendar.ts

@@ -89,6 +89,20 @@ export async function updateYear(
   }
 ) {
   await requireSchoolAdmin(input.schoolId, userId);
+  if (input.startDate !== undefined || input.endDate !== undefined) {
+    const existing = await getAcademicYearById(input.yearId, input.schoolId);
+    if (!existing) {
+      throw new TRPCError({ code: "NOT_FOUND", message: "Academic year not found" });
+    }
+    const nextStart = input.startDate ?? existing.startDate;
+    const nextEnd = input.endDate ?? existing.endDate;
+    if (nextEnd < nextStart) {
+      throw new TRPCError({
+        code: "BAD_REQUEST",
+        message: "endDate must be on or after startDate",
+      });
+    }
+  }
   const year = await updateAcademicYear(input.yearId, input.schoolId, {
     name: input.name,
     startDate: input.startDate,
@@ -177,6 +191,20 @@ export async function updateTerm(
   if (!year) {
     throw new TRPCError({ code: "NOT_FOUND", message: "Academic year not found" });
   }
+  if (input.startDate !== undefined || input.endDate !== undefined) {
+    const existingTerm = year.terms.find((t) => t.id === input.termId);
+    if (!existingTerm) {
+      throw new TRPCError({ code: "NOT_FOUND", message: "Academic term not found" });
+    }
+    const nextStart = input.startDate ?? existingTerm.startDate;
+    const nextEnd = input.endDate ?? existingTerm.endDate;
+    if (nextEnd < nextStart) {
+      throw new TRPCError({
+        code: "BAD_REQUEST",
+        message: "endDate must be on or after startDate",
+      });
+    }
+  }
   const term = await updateAcademicTerm(input.termId, input.yearId, {
     name: input.name,
     startDate: input.startDate,

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/attendance.ts

@@ -291,7 +291,11 @@ export async function updateAttendanceRecord(
   return shapeAttendanceSession(updated);
 }
 
-/** School-admin: today's attendance rollup across classes. */
+/**
+ * School-admin: today's attendance rollup across classes.
+ * `percentage` is session-weighted (share of attended class-session records),
+ * not a share of `totalStudents`; a student in six classes contributes six records.
+ */
 export async function listTodayAttendanceSummary(
   userId: string,
   schoolId: string
@@ -440,13 +444,13 @@ export async function listExcusals(
   const now = toDateOnly(new Date());
 
   return excusals.map((excusal) => {
-    let status: "ACTIVE" | "UPCOMING" | "REVOKED" = "ACTIVE";
+    let status: "ACTIVE" | "UPCOMING" | "EXPIRED" | "REVOKED" = "ACTIVE";
     if (excusal.revokedAt) {
       status = "REVOKED";
     } else if (toDateOnly(excusal.startDate) > now) {
       status = "UPCOMING";
     } else if (toDateOnly(excusal.endDate) < now) {
-      status = "ACTIVE"; // past but not revoked — still listed as ACTIVE historically
+      status = "EXPIRED";
     }
 
     return {

package/src/services/class.ts

@@ -2,7 +2,7 @@
  * Class service – CRUD for classes, members, grades, mark schemes, grading boundaries,
  * syllabus, lab drafts, and invite codes.
  */
-import { SessionType } from "@prisma/client";
+import { Prisma, SessionType } from "@prisma/client";
 import { TRPCError } from "@trpc/server";
 import { prisma } from "../lib/prisma.js";
 import { generateInviteCode } from "../utils/generateInviteCode.js";
@@ -247,7 +247,7 @@ export async function updateClass(
         studentsCanReply: data.studentsCanReply,
       }),
       ...(data.sidebarFeatures !== undefined && {
-        sidebarFeatures: data.sidebarFeatures,
+        sidebarFeatures: data.sidebarFeatures ?? Prisma.DbNull,
       }),
     } as Parameters<typeof prisma.class.update>[0]["data"],
     select: {

package/src/services/fees.ts

@@ -39,6 +39,20 @@ async function requireAdmin(schoolId: string, userId: string) {
   return membership;
 }
 
+async function assertActiveSchoolStudents(
+  schoolId: string,
+  studentIds: string[]
+) {
+  const activeIds = new Set(await listActiveStudentIds(schoolId));
+  const invalid = studentIds.filter((id) => !activeIds.has(id));
+  if (invalid.length > 0) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "One or more students are not active members of this school",
+    });
+  }
+}
+
 function assertMonth(month: number) {
   if (month < 1 || month > 12) {
     throw new TRPCError({
@@ -117,6 +131,7 @@ export async function createPlan(
     amountNpr: input.amountNpr,
   });
   if (input.studentIds?.length) {
+    await assertActiveSchoolStudents(input.schoolId, input.studentIds);
     const updated = await setFeePlanEnrollments(plan.id, input.studentIds);
     return { plan: updated };
   }
@@ -162,6 +177,7 @@ export async function setPlanStudents(
     throw new TRPCError({ code: "NOT_FOUND", message: "Fee plan not found" });
   }
   await requireAdmin(existing.schoolId, userId);
+  await assertActiveSchoolStudents(existing.schoolId, input.studentIds);
   const plan = await setFeePlanEnrollments(input.planId, input.studentIds);
   return { plan };
 }
@@ -192,7 +208,9 @@ export async function generateMonthlyInvoices(
   }
 
   let studentIds = input.studentIds;
-  if (!studentIds?.length) {
+  if (studentIds?.length) {
+    await assertActiveSchoolStudents(input.schoolId, studentIds);
+  } else {
     const enrolled = await listPlanEnrollmentIds(plan.id);
     studentIds = enrolled.length
       ? enrolled
@@ -410,7 +428,12 @@ export async function getReceiptPdf(userId: string, paymentId: string) {
       },
       {
         label: "Paid at",
-        value: payment.paidAt.toISOString().slice(0, 10),
+        value: new Intl.DateTimeFormat("en-CA", {
+          timeZone: "Asia/Kathmandu",
+          year: "numeric",
+          month: "2-digit",
+          day: "2-digit",
+        }).format(payment.paidAt),
       },
     ],
     footerNote: "Manual ledger receipt — gateway integration deferred.",

package/src/services/feesAuthz.ts

@@ -54,10 +54,7 @@ export function canManageFees(role: SchoolMembershipRole) {
   return FEE_WRITE_ROLES.includes(role);
 }
 
-/**
- * Placeholder procedure surface until A2 fee models exist.
- * Returns capability flags so the client can show/hide fee UI.
- */
+/** Returns capability flags so the client can show/hide fee UI. */
 export async function getFeeCapabilities(userId: string, schoolId: string) {
   const membership = await findActiveSchoolMembership(schoolId, userId);
   if (!membership) {
@@ -70,8 +67,7 @@ export async function getFeeCapabilities(userId: string, schoolId: string) {
     role: membership.role,
     canManageFees: canManageFees(membership.role),
     canViewFees: FEE_READ_ROLES.includes(membership.role),
-    feesImplemented: false as const,
-    message:
-      "Fee models are not implemented on this branch yet (owned by A2). Authz stubs are ready.",
+    feesImplemented: true as const,
+    message: "Fee features are available.",
   };
 }

package/src/services/marketplace.ts

@@ -21,6 +21,7 @@ import {
   incrementMarketplaceReportCount,
   searchMarketplaceListings,
   setMarketplaceListingHidden,
+  updateMarketplaceListing,
 } from "../models/marketplace.js";
 import {
   findActiveSchoolAdminMembership,
@@ -146,14 +147,19 @@ export async function listMarketplace(
   }
 ) {
   const memberships = await listUserSchoolMemberships(userId);
+  if (
+    input.schoolId &&
+    !memberships.some((m) => m.schoolId === input.schoolId)
+  ) {
+    return { items: [], nextCursor: undefined };
+  }
   const schoolIds = input.schoolId
-    ? memberships.some((m) => m.schoolId === input.schoolId)
-      ? [input.schoolId]
-      : []
+    ? [input.schoolId]
     : memberships.map((m) => m.schoolId);
 
   return searchMarketplaceListings({
     schoolIds,
+    scopeSchoolId: input.schoolId,
     type: input.type,
     search: input.search,
     tags: input.tags,
@@ -654,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,