@studious-lms/server 1.23.0 → 1.24.0

package/src/routers/academicCalendar.ts

@@ -0,0 +1,103 @@
+import { z } from "zod";
+import { createTRPCRouter, protectedProcedure } from "../trpc.js";
+import {
+  createTerm,
+  createYear,
+  getCurrentYear,
+  listYears,
+  promoteStudents,
+  removeTerm,
+  removeYear,
+  updateTerm,
+  updateYear,
+} from "../services/academicCalendar.js";
+
+const schoolIdSchema = z.object({ schoolId: z.string() });
+
+export const academicCalendarRouter = createTRPCRouter({
+  listYears: protectedProcedure
+    .input(schoolIdSchema)
+    .query(({ ctx, input }) => listYears(ctx.user!.id, input.schoolId)),
+
+  getCurrentYear: protectedProcedure
+    .input(schoolIdSchema)
+    .query(({ ctx, input }) => getCurrentYear(ctx.user!.id, input.schoolId)),
+
+  createYear: protectedProcedure
+    .input(
+      z.object({
+        schoolId: z.string(),
+        name: z.string().min(1),
+        startDate: z.date(),
+        endDate: z.date(),
+        isCurrent: z.boolean().optional(),
+      })
+    )
+    .mutation(({ ctx, input }) => createYear(ctx.user!.id, input)),
+
+  updateYear: protectedProcedure
+    .input(
+      z.object({
+        schoolId: z.string(),
+        yearId: z.string(),
+        name: z.string().min(1).optional(),
+        startDate: z.date().optional(),
+        endDate: z.date().optional(),
+        isCurrent: z.boolean().optional(),
+      })
+    )
+    .mutation(({ ctx, input }) => updateYear(ctx.user!.id, input)),
+
+  deleteYear: protectedProcedure
+    .input(z.object({ schoolId: z.string(), yearId: z.string() }))
+    .mutation(({ ctx, input }) => removeYear(ctx.user!.id, input)),
+
+  createTerm: protectedProcedure
+    .input(
+      z.object({
+        schoolId: z.string(),
+        yearId: z.string(),
+        name: z.string().min(1),
+        startDate: z.date(),
+        endDate: z.date(),
+        isCurrent: z.boolean().optional(),
+      })
+    )
+    .mutation(({ ctx, input }) => createTerm(ctx.user!.id, input)),
+
+  updateTerm: protectedProcedure
+    .input(
+      z.object({
+        schoolId: z.string(),
+        yearId: z.string(),
+        termId: z.string(),
+        name: z.string().min(1).optional(),
+        startDate: z.date().optional(),
+        endDate: z.date().optional(),
+        isCurrent: z.boolean().optional(),
+      })
+    )
+    .mutation(({ ctx, input }) => updateTerm(ctx.user!.id, input)),
+
+  deleteTerm: protectedProcedure
+    .input(
+      z.object({
+        schoolId: z.string(),
+        yearId: z.string(),
+        termId: z.string(),
+      })
+    )
+    .mutation(({ ctx, input }) => removeTerm(ctx.user!.id, input)),
+
+  /** C2: Move students from one class to another (basic promotion / rollover). */
+  promoteStudents: protectedProcedure
+    .input(
+      z.object({
+        schoolId: z.string(),
+        fromClassId: z.string(),
+        toClassId: z.string(),
+        studentUserIds: z.array(z.string()).min(1).max(500),
+      })
+    )
+    .mutation(({ ctx, input }) => promoteStudents(ctx.user!.id, input)),
+});

package/src/routers/assignment.ts

@@ -78,6 +78,10 @@ const createAssignmentSchema = z.object({
   gradingBoundaryId: z.string().optional(),
   inProgress: z.boolean().optional(),
   sourceAssignmentId: z.string().optional(),
+  timeLimitMinutes: z.number().int().min(1).max(1440).nullable().optional(),
+  singleAttempt: z.boolean().optional(),
+  allowLateSubmissions: z.boolean().optional(),
+  applyTypeDefaults: z.boolean().optional(),
 });
 
 const updateAssignmentSchema = z.object({
@@ -102,6 +106,10 @@ const updateAssignmentSchema = z.object({
   sectionId: z.string().nullable().optional(),
   type: z.enum(['HOMEWORK', 'QUIZ', 'TEST', 'PROJECT', 'ESSAY', 'DISCUSSION', 'PRESENTATION', 'LAB', 'OTHER']).optional(),
   inProgress: z.boolean().optional(),
+  timeLimitMinutes: z.number().int().min(1).max(1440).nullable().optional(),
+  singleAttempt: z.boolean().optional(),
+  allowLateSubmissions: z.boolean().optional(),
+  applyTypeDefaults: z.boolean().optional(),
 });
 
 const deleteAssignmentSchema = z.object({

package/src/routers/attendance.ts

@@ -7,11 +7,15 @@ import {
 import { TRPCError } from "@trpc/server";
 import { getAttendance, updateAttendanceRecord } from "../services/attendance.js";
 
+const studentRefSchema = z.object({ id: z.string(), username: z.string() });
+
 const attendanceSchema = z.object({
   eventId: z.string().optional(),
-  present: z.array(z.object({ id: z.string(), username: z.string() })),
-  late: z.array(z.object({ id: z.string(), username: z.string() })),
-  absent: z.array(z.object({ id: z.string(), username: z.string() })),
+  present: z.array(studentRefSchema),
+  late: z.array(studentRefSchema),
+  absent: z.array(studentRefSchema),
+  /** Optional; teachers may mark manual EXCUSED. Excusal-locked students stay EXCUSED. */
+  excused: z.array(studentRefSchema).optional(),
 });
 
 export const attendanceRouter = createTRPCRouter({

package/src/routers/class.ts

@@ -64,6 +64,10 @@ export const classRouter = createTRPCRouter({
         discussionsEnabled: z.boolean().optional(),
         studentsCanCreateDiscussions: z.boolean().optional(),
         studentsCanReply: z.boolean().optional(),
+        sidebarFeatures: z
+          .record(z.string(), z.boolean())
+          .nullable()
+          .optional(),
       })
     )
     .mutation(({ input }) => {

package/src/routers/fees.ts

@@ -0,0 +1,126 @@
+import { z } from "zod";
+import { createTRPCRouter, protectedProcedure } from "../trpc.js";
+import {
+  createPlan,
+  generateMonthlyInvoices,
+  getInvoice,
+  getInvoicePdf,
+  getPlan,
+  getReceiptPdf,
+  listBalances,
+  listInvoices,
+  listPlans,
+  recordPayment,
+  setPlanStudents,
+  updatePlan,
+} from "../services/fees.js";
+import { getFeeCapabilities } from "../services/feesAuthz.js";
+
+const schoolIdSchema = z.object({ schoolId: z.string() });
+
+const paymentMethodSchema = z.enum(["CASH", "BANK", "ESEWA_REF"]);
+const invoiceStatusSchema = z.enum(["UNPAID", "PARTIAL", "PAID", "VOID"]);
+
+export const feesRouter = createTRPCRouter({
+  listPlans: protectedProcedure
+    .input(schoolIdSchema)
+    .query(({ ctx, input }) => listPlans(ctx.user!.id, input.schoolId)),
+
+  getPlan: protectedProcedure
+    .input(z.object({ planId: z.string() }))
+    .query(({ ctx, input }) => getPlan(ctx.user!.id, input.planId)),
+
+  createPlan: protectedProcedure
+    .input(
+      z.object({
+        schoolId: z.string(),
+        name: z.string().min(1),
+        description: z.string().nullable().optional(),
+        amountNpr: z.number().int().positive(),
+        studentIds: z.array(z.string()).optional(),
+      })
+    )
+    .mutation(({ ctx, input }) => createPlan(ctx.user!.id, input)),
+
+  updatePlan: protectedProcedure
+    .input(
+      z.object({
+        planId: z.string(),
+        name: z.string().min(1).optional(),
+        description: z.string().nullable().optional(),
+        amountNpr: z.number().int().positive().optional(),
+        isActive: z.boolean().optional(),
+      })
+    )
+    .mutation(({ ctx, input }) => updatePlan(ctx.user!.id, input)),
+
+  setPlanStudents: protectedProcedure
+    .input(
+      z.object({
+        planId: z.string(),
+        studentIds: z.array(z.string()),
+      })
+    )
+    .mutation(({ ctx, input }) => setPlanStudents(ctx.user!.id, input)),
+
+  generateMonthlyInvoices: protectedProcedure
+    .input(
+      z.object({
+        schoolId: z.string(),
+        feePlanId: z.string(),
+        year: z.number().int().min(2000).max(2100),
+        month: z.number().int().min(1).max(12),
+        studentIds: z.array(z.string()).optional(),
+        dueDate: z.coerce.date().nullable().optional(),
+      })
+    )
+    .mutation(({ ctx, input }) =>
+      generateMonthlyInvoices(ctx.user!.id, input)
+    ),
+
+  listInvoices: protectedProcedure
+    .input(
+      z.object({
+        schoolId: z.string(),
+        year: z.number().int().optional(),
+        month: z.number().int().min(1).max(12).optional(),
+        studentId: z.string().optional(),
+        feePlanId: z.string().optional(),
+        status: invoiceStatusSchema.optional(),
+      })
+    )
+    .query(({ ctx, input }) => listInvoices(ctx.user!.id, input)),
+
+  getInvoice: protectedProcedure
+    .input(z.object({ invoiceId: z.string() }))
+    .query(({ ctx, input }) => getInvoice(ctx.user!.id, input.invoiceId)),
+
+  recordPayment: protectedProcedure
+    .input(
+      z.object({
+        invoiceId: z.string(),
+        amountNpr: z.number().int().positive(),
+        method: paymentMethodSchema,
+        reference: z.string().nullable().optional(),
+        paidAt: z.coerce.date().optional(),
+        notes: z.string().nullable().optional(),
+      })
+    )
+    .mutation(({ ctx, input }) => recordPayment(ctx.user!.id, input)),
+
+  listBalances: protectedProcedure
+    .input(schoolIdSchema)
+    .query(({ ctx, input }) => listBalances(ctx.user!.id, input.schoolId)),
+
+  getInvoicePdf: protectedProcedure
+    .input(z.object({ invoiceId: z.string() }))
+    .mutation(({ ctx, input }) => getInvoicePdf(ctx.user!.id, input.invoiceId)),
+
+  getReceiptPdf: protectedProcedure
+    .input(z.object({ paymentId: z.string() }))
+    .mutation(({ ctx, input }) => getReceiptPdf(ctx.user!.id, input.paymentId)),
+
+  getCapabilities: protectedProcedure
+    .input(schoolIdSchema)
+    .query(({ ctx, input }) => getFeeCapabilities(ctx.user!.id, input.schoolId)),
+});

package/src/routers/marketplace.ts

@@ -0,0 +1,134 @@
+/**
+ * Marketplace tRPC router — B1 v1.
+ * Exercise/poll/kahoot listing types are deferred; only MARKSCHEME|WORKSHEET|FILE.
+ */
+import { z } from "zod";
+import { createTRPCRouter, protectedProcedure } from "../trpc.js";
+import {
+  getMarketplaceListing,
+  hideMarketplaceListing,
+  importMarketplaceListing,
+  listMarketplace,
+  listPublishableSources,
+  publishFileListing,
+  publishMarkSchemeListing,
+  publishWorksheetListing,
+  reportMarketplaceListing,
+  unpublishMarketplaceListing,
+} from "../services/marketplace.js";
+
+const listingTypeSchema = z.enum(["MARKSCHEME", "WORKSHEET", "FILE"]);
+const visibilitySchema = z.enum(["SCHOOL", "PUBLIC"]);
+const tagsSchema = z.array(z.string().trim().min(1).max(40)).max(12).optional();
+
+const publishBase = {
+  title: z.string().trim().min(1).max(160),
+  description: z.string().trim().max(2000).optional(),
+  visibility: visibilitySchema,
+  schoolId: z.string().optional(),
+  tags: tagsSchema,
+};
+
+export const marketplaceRouter = createTRPCRouter({
+  /** Search / list visible listings (school + public). */
+  list: protectedProcedure
+    .input(
+      z.object({
+        type: listingTypeSchema.optional(),
+        search: z.string().trim().max(120).optional(),
+        tags: tagsSchema,
+        schoolId: z.string().optional(),
+        cursor: z.string().optional(),
+        limit: z.number().int().min(1).max(50).default(20),
+      })
+    )
+    .query(({ ctx, input }) => listMarketplace(ctx.user!.id, input)),
+
+  get: protectedProcedure
+    .input(z.object({ listingId: z.string() }))
+    .query(({ ctx, input }) =>
+      getMarketplaceListing(ctx.user!.id, input.listingId)
+    ),
+
+  /** Sources the caller can publish from (for the publish dialog). */
+  listPublishableSources: protectedProcedure
+    .input(
+      z.object({
+        classId: z.string().optional(),
+        schoolId: z.string().optional(),
+      })
+    )
+    .query(({ ctx, input }) => listPublishableSources(ctx.user!.id, input)),
+
+  publishMarkScheme: protectedProcedure
+    .input(
+      z.object({
+        ...publishBase,
+        markSchemeId: z.string(),
+      })
+    )
+    .mutation(({ ctx, input }) =>
+      publishMarkSchemeListing(ctx.user!.id, input)
+    ),
+
+  publishWorksheet: protectedProcedure
+    .input(
+      z.object({
+        ...publishBase,
+        worksheetId: z.string(),
+      })
+    )
+    .mutation(({ ctx, input }) =>
+      publishWorksheetListing(ctx.user!.id, input)
+    ),
+
+  publishFile: protectedProcedure
+    .input(
+      z.object({
+        ...publishBase,
+        fileId: z.string(),
+      })
+    )
+    .mutation(({ ctx, input }) => publishFileListing(ctx.user!.id, input)),
+
+  /**
+   * Import / download a listing copy into the caller's class, department,
+   * or storage folder.
+   */
+  import: protectedProcedure
+    .input(
+      z.object({
+        listingId: z.string(),
+        classId: z.string().optional(),
+        departmentId: z.string().optional(),
+        folderId: z.string().optional(),
+        name: z.string().trim().min(1).max(160).optional(),
+      })
+    )
+    .mutation(({ ctx, input }) =>
+      importMarketplaceListing(ctx.user!.id, input)
+    ),
+
+  report: protectedProcedure
+    .input(z.object({ listingId: z.string() }))
+    .mutation(({ ctx, input }) =>
+      reportMarketplaceListing(ctx.user!.id, input.listingId)
+    ),
+
+  setHidden: protectedProcedure
+    .input(
+      z.object({
+        listingId: z.string(),
+        isHidden: z.boolean(),
+      })
+    )
+    .mutation(({ ctx, input }) =>
+      hideMarketplaceListing(ctx.user!.id, input.listingId, input.isHidden)
+    ),
+
+  unpublish: protectedProcedure
+    .input(z.object({ listingId: z.string() }))
+    .mutation(({ ctx, input }) =>
+      unpublishMarketplaceListing(ctx.user!.id, input.listingId)
+    ),
+});

package/src/routers/moduleItem.ts

@@ -0,0 +1,89 @@
+import { z } from "zod";
+import {
+  createTRPCRouter,
+  protectedClassMemberProcedure,
+  protectedTeacherProcedure,
+} from "../trpc.js";
+import {
+  createModuleItemRecord,
+  deleteModuleItemRecord,
+  getModuleItem,
+  listModuleItemsForClass,
+  listModuleItemsForSection,
+  reorderModuleItems,
+  updateModuleItemRecord,
+} from "../services/moduleItem.js";
+
+const directFileSchema = z.object({
+  name: z.string(),
+  type: z.string(),
+  size: z.number(),
+});
+
+const moduleItemTypeSchema = z.enum(["PAGE", "FILES", "VIDEO"]);
+
+export const moduleItemRouter = createTRPCRouter({
+  listByClass: protectedClassMemberProcedure
+    .input(z.object({ classId: z.string() }))
+    .query(({ ctx, input }) =>
+      listModuleItemsForClass(input.classId, ctx.user!.id)
+    ),
+
+  listBySection: protectedClassMemberProcedure
+    .input(z.object({ sectionId: z.string() }))
+    .query(({ ctx, input }) =>
+      listModuleItemsForSection(input.sectionId, ctx.user!.id)
+    ),
+
+  get: protectedClassMemberProcedure
+    .input(z.object({ id: z.string() }))
+    .query(({ ctx, input }) => getModuleItem(input.id, ctx.user!.id)),
+
+  create: protectedTeacherProcedure
+    .input(
+      z.object({
+        classId: z.string(),
+        sectionId: z.string(),
+        title: z.string().min(1).max(500),
+        type: moduleItemTypeSchema,
+        body: z.string().max(200_000).nullable().optional(),
+        published: z.boolean().optional(),
+        files: z.array(directFileSchema).optional(),
+        existingFileIds: z.array(z.string()).optional(),
+      })
+    )
+    .mutation(({ ctx, input }) => createModuleItemRecord(ctx.user!.id, input)),
+
+  update: protectedTeacherProcedure
+    .input(
+      z.object({
+        classId: z.string(),
+        id: z.string(),
+        title: z.string().min(1).max(500).optional(),
+        type: moduleItemTypeSchema.optional(),
+        body: z.string().max(200_000).nullable().optional(),
+        published: z.boolean().optional(),
+        sectionId: z.string().optional(),
+        order: z.number().int().nullable().optional(),
+        files: z.array(directFileSchema).optional(),
+        existingFileIds: z.array(z.string()).optional(),
+      })
+    )
+    .mutation(({ ctx, input }) => updateModuleItemRecord(ctx.user!.id, input)),
+
+  reorder: protectedTeacherProcedure
+    .input(
+      z.object({
+        classId: z.string(),
+        sectionId: z.string(),
+        orderedIds: z.array(z.string()),
+      })
+    )
+    .mutation(({ ctx, input }) => reorderModuleItems(ctx.user!.id, input)),
+
+  delete: protectedTeacherProcedure
+    .input(z.object({ classId: z.string(), id: z.string() }))
+    .mutation(({ ctx, input }) =>
+      deleteModuleItemRecord(ctx.user!.id, input.id)
+    ),
+});

package/src/routers/parent.ts

@@ -0,0 +1,68 @@
+import { z } from "zod";
+import { createTRPCRouter, protectedProcedure } from "../trpc.js";
+import {
+  getChildAttendance,
+  getChildGrades,
+  linkParentToStudent,
+  listMyChildren,
+  listParentLinks,
+  unlinkParentFromStudent,
+} from "../services/parentPortal.js";
+
+export const parentRouter = createTRPCRouter({
+  linkStudent: protectedProcedure
+    .input(
+      z.object({
+        schoolId: z.string(),
+        parentUserId: z.string(),
+        studentUserId: z.string(),
+      })
+    )
+    .mutation(({ ctx, input }) => linkParentToStudent(ctx.user!.id, input)),
+
+  unlinkStudent: protectedProcedure
+    .input(
+      z.object({
+        schoolId: z.string(),
+        parentUserId: z.string(),
+        studentUserId: z.string(),
+      })
+    )
+    .mutation(({ ctx, input }) => unlinkParentFromStudent(ctx.user!.id, input)),
+
+  listLinks: protectedProcedure
+    .input(
+      z.object({
+        schoolId: z.string(),
+        parentUserId: z.string().optional(),
+        studentUserId: z.string().optional(),
+      })
+    )
+    .query(({ ctx, input }) => listParentLinks(ctx.user!.id, input)),
+
+  listMyChildren: protectedProcedure
+    .input(z.object({ schoolId: z.string() }))
+    .query(({ ctx, input }) => listMyChildren(ctx.user!.id, input.schoolId)),
+
+  getChildAttendance: protectedProcedure
+    .input(
+      z.object({
+        schoolId: z.string(),
+        studentUserId: z.string(),
+        classId: z.string().optional(),
+        from: z.date().optional(),
+        to: z.date().optional(),
+      })
+    )
+    .query(({ ctx, input }) => getChildAttendance(ctx.user!.id, input)),
+
+  getChildGrades: protectedProcedure
+    .input(
+      z.object({
+        schoolId: z.string(),
+        studentUserId: z.string(),
+        classId: z.string().optional(),
+      })
+    )
+    .query(({ ctx, input }) => getChildGrades(ctx.user!.id, input)),
+});