@anantagnanam/lms 0.2.0 → 0.3.0

package/dist/runtime.js

@@ -1,7 +1,7 @@
-import { a as adminPages, i as PLUGIN_VERSION, n as MAX_DOCUMENT_BYTES, o as storage, r as PLUGIN_ID } from "./constants-Cnx7k82Z.js";
+import { a as adminPages, i as PLUGIN_VERSION, n as MAX_DOCUMENT_BYTES, o as storage, r as PLUGIN_ID } from "./constants-DyQbwNbP.js";
 import { t as normalizeLmsOptions } from "./config-BX3beTpM.js";
-import { assignmentSubmitSchema, catalogSchema, certificateActionSchema, certificateRevokeSchema, cohortSaveSchema, courseDataSchema, courseIdSchema, courseSaveSchema, discussionSchema, enrollmentAdminSchema, enrollmentRequestSchema, gradeSchema, idSchema, keySchema, lessonIdSchema, moderateSchema, noteSchema, pageSchema, pathSaveSchema, playbackSchema, preferencesSchema, quizDraftSchema, quizSubmitSchema, reviewSchema, settingsSchema } from "./schemas.js";
-import { n as invariant, t as LmsError } from "./errors-ChzJS9al.js";
+import { assignmentDraftSchema, assignmentSubmitSchema, catalogSchema, certificateActionSchema, certificateRevokeSchema, cohortSaveSchema, courseDataSchema, courseIdSchema, courseSaveSchema, discussionSchema, enrollmentAdminSchema, enrollmentRequestSchema, gradeSchema, idSchema, keySchema, lessonIdSchema, moderateSchema, noteSchema, pageSchema, pathSaveSchema, playbackSchema, preferencesSchema, quizDraftSchema, quizSubmitSchema, reviewSchema, settingsSchema, studyNoteSchema } from "./schemas.js";
+import { a as invariant, i as LmsError, n as assignmentGrade, r as emptyAssignmentDraft, t as assignmentBlock } from "./assignments-CsuAjxGO.js";
 import { n as enrollmentCsvLines, t as enrollmentCsvHeader } from "./csv-DKq_4OWU.js";
 import { definePlugin, definePluginRoute, pluginResponse } from "emdash";
 import { z } from "zod";
@@ -356,9 +356,12 @@ function publicEnrollment(enrollment, now = /* @__PURE__ */ new Date()) {
 /** Staff need assessment and completion records, not a learner's private study notes. */
 function staffEnrollment(enrollment, now = /* @__PURE__ */ new Date()) {
 	const view = publicEnrollment(enrollment, now);
+	delete view.studyNotes;
 	for (const progress of Object.values(view.progress)) {
 		progress.note = "";
+		delete progress.noteRevision;
 		delete progress.playback;
+		delete progress.assignmentDraft;
 	}
 	return view;
 }
@@ -1295,6 +1298,54 @@ var LmsService = class {
 			})
 		};
 	}
+	async assignmentState(actor, courseId, lessonId) {
+		const current = user$1(actor);
+		const course = await this.course(courseId);
+		const enrollment = await this.stores.enrollments.get(enrollmentKey(courseId, current.id));
+		const lesson = await this.lessonAccess(course, lessonId, enrollment);
+		invariant(lesson.kind === "assignment" && lesson.assignment, "NOT_AN_ASSIGNMENT", "This lesson has no assignment.");
+		const progress = enrollment.progress[lessonId] ?? emptyProgress();
+		const blocked = assignmentBlock(lesson.assignment, progress, this.now());
+		return {
+			draft: progress.assignmentDraft ?? emptyAssignmentDraft(),
+			submission: progress.assignments.at(-1) ?? null,
+			canSubmit: !blocked,
+			closedReason: blocked?.message ?? null
+		};
+	}
+	async saveAssignmentDraft(actor, input) {
+		const current = user$1(actor);
+		const parsed = parse(assignmentDraftSchema, input);
+		const course = await this.course(parsed.courseId);
+		return {
+			saved: true,
+			draftRevision: await change(this.stores.enrollments, enrollmentKey(course.id, current.id), async (stored) => {
+				const lesson = await this.lessonAccess(course, parsed.lessonId, stored);
+				invariant(lesson.kind === "assignment" && lesson.assignment, "NOT_AN_ASSIGNMENT", "This lesson has no assignment.");
+				const next = structuredClone(stored);
+				const progress = next.progress[parsed.lessonId] ?? emptyProgress();
+				const draft = progress.assignmentDraft ?? emptyAssignmentDraft();
+				const blocked = assignmentBlock(lesson.assignment, progress, this.now());
+				if (blocked) throw new LmsError(blocked.code, blocked.message, blocked.status);
+				if (draft.revision === parsed.expectedDraftRevision + 1 && draft.body === parsed.body && draft.attachmentUrl === parsed.attachmentUrl) return {
+					value: next,
+					result: draft.revision
+				};
+				invariant(draft.revision === parsed.expectedDraftRevision, "DRAFT_CONFLICT", "Your assignment draft changed in another request. Review it before saving.", 409);
+				progress.assignmentDraft = {
+					body: parsed.body,
+					attachmentUrl: parsed.attachmentUrl,
+					revision: draft.revision + 1,
+					updatedAt: this.time()
+				};
+				next.progress[parsed.lessonId] = progress;
+				return {
+					value: next,
+					result: progress.assignmentDraft.revision
+				};
+			})
+		};
+	}
 	async submitAssignment(actor, input) {
 		const current = user$1(actor);
 		const parsed = parse(assignmentSubmitSchema, input);
@@ -1302,16 +1353,23 @@ var LmsService = class {
 		const enrollment = await change(this.stores.enrollments, enrollmentKey(course.id, current.id), async (stored) => {
 			const lesson = await this.lessonAccess(course, parsed.lessonId, stored);
 			invariant(lesson.kind === "assignment" && lesson.assignment, "NOT_AN_ASSIGNMENT", "This lesson has no assignment.");
-			invariant(!lesson.assignment.dueAt || this.now().getTime() <= Date.parse(lesson.assignment.dueAt), "ASSIGNMENT_CLOSED", "The assignment deadline has passed.", 403);
 			const next = structuredClone(stored);
 			const progress = next.progress[parsed.lessonId] ?? emptyProgress();
-			const last = progress.assignments.at(-1);
-			invariant(!progress.completedAt, "ASSIGNMENT_PASSED", "This assignment has already been passed.", 409);
-			invariant(!last || last.status === "graded" && lesson.assignment.allowResubmission, "SUBMISSION_PENDING", "Wait for grading before submitting again.", 409);
-			invariant(progress.assignments.length < 10, "SUBMISSION_LIMIT", "The assignment submission limit has been reached.", 403);
+			const previous = parsed.submissionId && progress.assignments.find((item) => item.id === parsed.submissionId);
+			if (previous) {
+				invariant(previous.body === parsed.body && previous.attachmentUrl === parsed.attachmentUrl, "SUBMISSION_CONFLICT", "This submission ID already belongs to different work.", 409);
+				return {
+					value: next,
+					result: next
+				};
+			}
+			const blocked = assignmentBlock(lesson.assignment, progress, this.now());
+			if (blocked) throw new LmsError(blocked.code, blocked.message, blocked.status);
+			const draft = progress.assignmentDraft ?? emptyAssignmentDraft();
+			invariant(parsed.expectedDraftRevision === void 0 ? !draft.body && !draft.attachmentUrl : draft.revision === parsed.expectedDraftRevision, "DRAFT_CONFLICT", "Your assignment draft changed. Review it before submitting.", 409);
 			progress.startedAt ??= this.time();
 			progress.assignments.push({
-				id: crypto.randomUUID(),
+				id: parsed.submissionId ?? crypto.randomUUID(),
 				body: parsed.body,
 				attachmentUrl: parsed.attachmentUrl,
 				submittedAt: this.time(),
@@ -1321,8 +1379,16 @@ var LmsService = class {
 				points: null,
 				feedback: "",
 				gradedAt: null,
-				gradedBy: null
+				gradedBy: null,
+				rubric: structuredClone(lesson.assignment.rubric ?? []),
+				rubricScores: []
 			});
+			progress.assignmentDraft = {
+				body: "",
+				attachmentUrl: null,
+				revision: draft.revision + 1,
+				updatedAt: this.time()
+			};
 			next.progress[parsed.lessonId] = progress;
 			next.lastActivityAt = this.time();
 			return {
@@ -1344,13 +1410,14 @@ var LmsService = class {
 			const submission = progress?.assignments.find((item) => item.id === parsed.submissionId);
 			invariant(submission && progress, "NOT_FOUND", "Assignment submission not found.", 404);
 			invariant(submission.status === "submitted", "ALREADY_GRADED", "This submission has already been graded.", 409);
-			invariant(parsed.points <= submission.maxPoints, "INVALID_GRADE", "The grade cannot exceed the assignment's maximum points.");
-			submission.points = parsed.points;
+			const grade = assignmentGrade(submission, parsed.points, parsed.rubricScores);
+			submission.points = grade.points;
+			submission.rubricScores = grade.rubricScores;
 			submission.feedback = parsed.feedback;
 			submission.status = "graded";
 			submission.gradedAt = this.time();
 			submission.gradedBy = current.id;
-			if (parsed.points >= submission.passingPoints) progress.completedAt ??= this.time();
+			if (grade.points >= submission.passingPoints) progress.completedAt ??= this.time();
 			const access = effectiveAccess(await this.accessEnrollment(next), this.now());
 			if (["active", "completed"].includes(next.status) && ![
 				"suspended",
@@ -1366,7 +1433,8 @@ var LmsService = class {
 		await this.notify(enrollment, `graded-${parsed.submissionId}`, "Assignment graded", "Your assignment feedback is ready in My Learning.");
 		await this.audit(current, "assignment.grade", enrollment.id, {
 			lessonId: parsed.lessonId,
-			points: parsed.points
+			submissionId: parsed.submissionId,
+			points: enrollment.progress[parsed.lessonId].assignments.find((item) => item.id === parsed.submissionId).points
 		});
 		return staffEnrollment(await this.accessEnrollment(enrollment), this.now());
 	}
@@ -1374,17 +1442,28 @@ var LmsService = class {
 		const current = user$1(actor);
 		const parsed = parse(noteSchema, input);
 		const course = await this.course(parsed.courseId);
-		return { note: (await change(this.stores.enrollments, enrollmentKey(course.id, current.id), async (stored) => {
+		const enrollment = await change(this.stores.enrollments, enrollmentKey(course.id, current.id), async (stored) => {
 			await this.lessonAccess(course, parsed.lessonId, stored);
 			const next = structuredClone(stored);
 			const progress = next.progress[parsed.lessonId] ?? emptyProgress();
+			const revision = progress.noteRevision ?? 0;
+			if (revision === parsed.expectedRevision + 1 && progress.note === parsed.note) return {
+				value: next,
+				result: next
+			};
+			invariant(revision === parsed.expectedRevision, "NOTE_CONFLICT", "Your lesson notes changed in another tab. Copy your work before reloading to compare it with the saved notes.", 409);
 			progress.note = parsed.note;
+			progress.noteRevision = revision + 1;
 			next.progress[parsed.lessonId] = progress;
 			return {
 				value: next,
 				result: next
 			};
-		})).progress[parsed.lessonId].note };
+		});
+		return {
+			note: enrollment.progress[parsed.lessonId].note,
+			revision: enrollment.progress[parsed.lessonId].noteRevision ?? 0
+		};
 	}
 	async certificate(actor, courseId) {
 		const current = user$1(actor);
@@ -2411,6 +2490,191 @@ var LearningFeatures = class {
 	}
 };
 
+//#endregion
+//#region src/study.ts
+function owner(actor) {
+	invariant(actor, "UNAUTHORIZED", "Sign in to continue.", 401);
+	return actor;
+}
+/** Personal study data is retained separately from access and completion decisions. */
+var StudyTools = class {
+	constructor(service) {
+		this.service = service;
+	}
+	async courses(actor, input) {
+		const current = owner(actor);
+		const page = await queryPage(this.service.stores.enrollments, {
+			...parse(pageSchema, input),
+			where: { userId: current.id },
+			orderBy: { enrolledAt: "desc" }
+		});
+		return {
+			...page,
+			items: await Promise.all(page.items.map(async (enrollment) => {
+				const source = await this.service.stores.courses.get(enrollment.courseId);
+				const course = source ? await this.service.editions.learning(source, enrollment) : null;
+				return {
+					courseId: enrollment.courseId,
+					title: course?.title ?? "Unavailable course",
+					slug: course?.slug ?? null
+				};
+			}))
+		};
+	}
+	async notebook(actor, input) {
+		const current = owner(actor);
+		const { courseId } = parse(courseIdSchema, input);
+		const stored = await this.service.stores.enrollments.get(enrollmentKey(courseId, current.id));
+		invariant(stored, "NOT_FOUND", "Your course notebook was not found.", 404);
+		const source = await this.service.stores.courses.get(courseId);
+		const course = source ? await this.service.editions.learning(source, stored) : null;
+		const resolved = await this.service.accessEnrollment(stored);
+		const all = course ? lessons(course) : [];
+		return {
+			course: {
+				id: courseId,
+				title: course?.title ?? "Unavailable course",
+				slug: course?.slug ?? ""
+			},
+			notes: stored.studyNotes ?? [],
+			summaries: Object.entries(stored.progress).flatMap(([lessonId, progress]) => progress.note ? [{
+				lessonId,
+				lessonTitle: all.find((lesson) => lesson.id === lessonId)?.title ?? "Lesson",
+				body: progress.note
+			}] : []),
+			availableLessonIds: course ? all.filter((lesson) => lessonAvailability(course, lesson.id, resolved, this.service.now()).available).map((lesson) => lesson.id) : []
+		};
+	}
+	async saveNote(actor, input) {
+		const current = owner(actor);
+		const parsed = parse(studyNoteSchema, input);
+		const course = await this.service.course(parsed.courseId);
+		return change(this.service.stores.enrollments, enrollmentKey(course.id, current.id), async (stored) => {
+			const lesson = await this.service.lessonAccess(course, parsed.lessonId, stored);
+			invariant(parsed.positionSeconds === null || ["video", "audio"].includes(lesson.kind), "INVALID_TIMESTAMP", "Timestamps belong to audio or video lessons.");
+			const next = structuredClone(stored);
+			const notes = next.studyNotes ??= [];
+			const existing = notes.find((note) => note.id === parsed.id);
+			invariant(!existing || existing.lessonId === lesson.id, "NOTE_CONFLICT", "This note belongs to another lesson.", 409);
+			const same = existing && existing.body === parsed.body && existing.positionSeconds === parsed.positionSeconds && existing.starred === parsed.starred && existing.archived === parsed.archived;
+			if (existing && same && existing.revision === parsed.expectedRevision + 1) return {
+				value: next,
+				result: existing
+			};
+			invariant((existing?.revision ?? 0) === parsed.expectedRevision, "NOTE_CONFLICT", "This note changed in another tab. Your edits are still here; reload the saved note to compare.", 409);
+			invariant(existing || notes.length < 100, "NOTE_LIMIT", "This course notebook has reached its limit of 100 notes, including archived notes. Edit an existing note instead.", 409);
+			const note = {
+				id: parsed.id,
+				lessonId: lesson.id,
+				lessonTitle: existing?.lessonTitle ?? lesson.title,
+				body: parsed.body,
+				positionSeconds: parsed.positionSeconds,
+				starred: parsed.starred,
+				archived: parsed.archived,
+				revision: (existing?.revision ?? 0) + 1,
+				createdAt: existing?.createdAt ?? this.service.time(),
+				updatedAt: this.service.time()
+			};
+			if (existing) notes[notes.indexOf(existing)] = note;
+			else notes.push(note);
+			invariant(new TextEncoder().encode(JSON.stringify(notes)).byteLength <= 15e4, "NOTE_LIMIT", "This course notebook has reached its storage limit. Shorten an existing note to make room; archived notes still count.", 409);
+			return {
+				value: next,
+				result: note
+			};
+		});
+	}
+	async agenda(actor, input) {
+		const current = owner(actor);
+		const { courseId } = parse(courseIdSchema, input);
+		const source = await this.service.course(courseId);
+		const stored = await this.service.stores.enrollments.get(enrollmentKey(courseId, current.id));
+		const enrollment = await this.service.accessEnrollment(stored);
+		assertEnrollmentAccess(enrollment, this.service.now());
+		const course = await this.service.editions.learning(source, enrollment);
+		const now = this.service.now();
+		const events = [];
+		for (const lesson of lessons(course)) {
+			const access = lessonAvailability(course, lesson.id, enrollment, now);
+			const progress = enrollment.progress[lesson.id];
+			const append = (kind, startsAt, endsAt) => {
+				const past = Date.parse(startsAt) < now.getTime();
+				events.push({
+					id: `${course.id}-${lesson.id}-${kind}`,
+					kind,
+					lessonId: lesson.id,
+					title: lesson.title,
+					startsAt,
+					endsAt,
+					available: access.available,
+					reason: access.reason,
+					status: progress?.completedAt ? "completed" : kind === "assignment" && progress?.assignments.at(-1)?.status === "submitted" ? "submitted" : past ? kind === "assignment" ? "overdue" : "past" : "upcoming"
+				});
+			};
+			if (lesson.assignment?.dueAt) append("assignment", lesson.assignment.dueAt, null);
+			if (lesson.kind === "live" && lesson.liveStartsAt) append("live", lesson.liveStartsAt, new Date(Date.parse(lesson.liveStartsAt) + Math.max(1, lesson.durationMinutes) * 6e4).toISOString());
+			if (access.code === "LESSON_LOCKED" && access.releaseAt) append("release", access.releaseAt, null);
+		}
+		events.sort((a, b) => Date.parse(a.startsAt) - Date.parse(b.startsAt) || a.id.localeCompare(b.id));
+		return {
+			course: {
+				id: course.id,
+				title: course.title,
+				slug: course.slug
+			},
+			generatedAt: now.toISOString(),
+			events
+		};
+	}
+};
+
+//#endregion
+//#region src/calendar.ts
+const text = (value) => value.replace(/\r\n|\r/g, "\n").replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, "").replace(/\\/g, "\\\\").replace(/\n/g, "\\n").replace(/;/g, "\\;").replace(/,/g, "\\,");
+const date = (value) => new Date(value).toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+/** RFC 5545 folding counts UTF-8 octets, including the continuation space. */
+function foldCalendarLine(value) {
+	const encoder = new TextEncoder();
+	let line = "";
+	let bytes = 0;
+	const lines = [];
+	for (const char of value) {
+		const size = encoder.encode(char).byteLength;
+		if (bytes + size > 75) {
+			lines.push(line);
+			line = " ";
+			bytes = 1;
+		}
+		line += char;
+		bytes += size;
+	}
+	lines.push(line);
+	return lines.join("\r\n");
+}
+/** A private downloadable snapshot: no subscription token, meeting URL or alarm. */
+function courseCalendar(agenda, origin, basePath) {
+	const lines = [
+		"BEGIN:VCALENDAR",
+		"VERSION:2.0",
+		"PRODID:-//Ananta Gnanam//LMS//EN",
+		"CALSCALE:GREGORIAN",
+		"METHOD:PUBLISH"
+	];
+	for (const event of agenda.events.filter((item) => item.status === "upcoming")) {
+		const kind = {
+			assignment: "Assignment due",
+			live: "Live session",
+			release: "Lesson release"
+		}[event.kind];
+		const url = new URL(`${basePath}/courses/${encodeURIComponent(agenda.course.slug)}/lessons/${encodeURIComponent(event.lessonId)}`, origin).href;
+		lines.push("BEGIN:VEVENT", `UID:${event.id}@anantagnanam-lms`, `DTSTAMP:${date(agenda.generatedAt)}`, `DTSTART:${date(event.startsAt)}`);
+		if (event.endsAt) lines.push(`DTEND:${date(event.endsAt)}`);
+		lines.push(`SUMMARY:${text(`${kind}: ${event.title}`)}`, `DESCRIPTION:${text(`${agenda.course.title}. Check the course for current access and requirements. This downloaded calendar does not update automatically.`)}`, `URL:${url}`, "CLASS:PRIVATE", `STATUS:${event.available ? "CONFIRMED" : "TENTATIVE"}`, "END:VEVENT");
+	}
+	lines.push("END:VCALENDAR");
+	return lines.map(foldCalendarLine).join("\r\n") + "\r\n";
+}
+
 //#endregion
 //#region src/runtime.ts
 const listSchema = pageSchema.extend({
@@ -2513,6 +2777,28 @@ function createPlugin(_options = {}) {
 			}
 		},
 		routes: {
+			"learner/study/courses": get((ctx, service) => new StudyTools(service).courses(ctx.user, ctx.input)),
+			"learner/notebook": get((ctx, service) => new StudyTools(service).notebook(ctx.user, ctx.input)),
+			"learner/notebook/save": post((ctx, service) => new StudyTools(service).saveNote(ctx.user, ctx.input)),
+			"learner/agenda": get((ctx, service) => new StudyTools(service).agenda(ctx.user, ctx.input)),
+			"learner/agenda/calendar": definePluginRoute({
+				methods: ["GET"],
+				permission: "content:read",
+				request: { body: "none" },
+				response: "raw",
+				handler: async (ctx) => {
+					return pluginResponse({
+						body: {
+							kind: "text",
+							value: courseCalendar(await new StudyTools(new LmsService(ctx)).agenda(ctx.user, ctx.input), new URL(ctx.request.url).origin, options.basePath)
+						},
+						headers: {
+							"Content-Type": "text/calendar; charset=utf-8",
+							"Content-Disposition": "attachment; filename=\"lms-course-agenda.ics\""
+						}
+					});
+				}
+			}),
 			paths: get(async (ctx, service) => new LearningFeatures(service).paths(ctx.input), true),
 			"learner/paths": get(async (ctx, service) => new LearningFeatures(service).learnerPaths(ctx.user, ctx.input)),
 			"learner/path/join": post(async (ctx, service) => new LearningFeatures(service).joinPath(ctx.user, ctx.input)),
@@ -2573,6 +2859,11 @@ function createPlugin(_options = {}) {
 			"learner/quiz/submit": post(async (ctx, service) => service.submitQuiz(ctx.user, ctx.input)),
 			"learner/quiz/draft": post(async (ctx, service) => service.saveQuizDraft(ctx.user, ctx.input)),
 			"learner/assignment": post(async (ctx, service) => service.submitAssignment(ctx.user, ctx.input)),
+			"learner/assignment/state": get(async (ctx, service) => {
+				const input = parse(lessonIdSchema, ctx.input);
+				return service.assignmentState(ctx.user, input.courseId, input.lessonId);
+			}),
+			"learner/assignment/draft": post(async (ctx, service) => service.saveAssignmentDraft(ctx.user, ctx.input)),
 			"learner/note": post(async (ctx, service) => service.saveNote(ctx.user, ctx.input)),
 			"learner/discussions": get(async (ctx, service) => {
 				const input = parse(lessonIdSchema.extend({ cursor: z.string().optional() }), ctx.input);