@studious-lms/server 1.22.0 → 1.24.0

package/scripts/import-nepal-cdc-curriculum.ts

@@ -0,0 +1,379 @@
+/**
+ * Import Nepal CDC G4–5 curriculum pack as department-level MarkScheme /
+ * GradingBoundary templates.
+ *
+ * Usage:
+ *   npx tsx scripts/import-nepal-cdc-curriculum.ts --departmentId=<uuid>
+ *   npm run curriculum:import-nepal-cdc -- --departmentId=<uuid> --dry-run
+ *
+ * Options:
+ *   --departmentId   Required. Target department for templates.
+ *   --schoolId       Optional. Defaults to the department's school.
+ *   --grades         Optional. Comma list: 4,5 (default both).
+ *   --subjects       Optional. Comma list of subject keys (default all).
+ *   --skip-boundary  Skip creating the 1–4 proficiency GradingBoundary.
+ *   --dry-run        Parse and report without writing.
+ *   --force          Re-import even if a template with the same name exists
+ *                    (creates duplicates; default skips existing names).
+ */
+import { readFileSync, readdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { prisma } from "../src/lib/prisma.js";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PACK_DIR = join(__dirname, "../data/curriculum/nepal-cdc-g4-g5");
+
+type PackCriterion = {
+  id: string;
+  title: string;
+  description: string;
+  levels: Array<{
+    id: string;
+    name: string;
+    description: string;
+    points: number;
+    color: string;
+  }>;
+  meta?: Record<string, unknown>;
+};
+
+type PackUnit = {
+  id: string;
+  grade: 4 | 5;
+  subjectKey: string;
+  unitNumber: number;
+  titleEn: string;
+  titleNe: string | null;
+  transcriptionStatus: string;
+  notes?: string | null;
+  tags: string[];
+  markScheme: {
+    name: string;
+    description: string;
+    category: string;
+    totalPoints: number;
+    criteria: PackCriterion[];
+  };
+};
+
+type SubjectFile = {
+  key: string;
+  nameEn: string;
+  nameNe: string;
+  units: PackUnit[];
+};
+
+type ProficiencyScale = {
+  gradingBoundary: {
+    name: string;
+    description?: string;
+    boundaries: Array<{
+      id: string;
+      grade: string;
+      minPercentage: number;
+      maxPercentage: number;
+      color: string;
+      description?: string;
+    }>;
+  };
+};
+
+function parseArgs(argv: string[]) {
+  const out: Record<string, string | boolean> = {};
+  for (const arg of argv) {
+    if (!arg.startsWith("--")) continue;
+    const eq = arg.indexOf("=");
+    if (eq === -1) {
+      out[arg.slice(2)] = true;
+    } else {
+      out[arg.slice(2, eq)] = arg.slice(eq + 1);
+    }
+  }
+  return out;
+}
+
+function loadJson<T>(path: string): T {
+  return JSON.parse(readFileSync(path, "utf8")) as T;
+}
+
+function stripCriterionMeta(criteria: PackCriterion[]) {
+  return criteria.map(({ id, title, description, levels }) => ({
+    id,
+    title,
+    description,
+    levels,
+  }));
+}
+
+function buildMarkSchemeStructured(unit: PackUnit) {
+  return JSON.stringify({
+    name: unit.markScheme.name,
+    description: unit.markScheme.description,
+    category: unit.markScheme.category,
+    totalPoints: unit.markScheme.totalPoints,
+    criteria: stripCriterionMeta(unit.markScheme.criteria),
+    curriculumMeta: {
+      packId: "nepal-cdc-g4-g5-2083",
+      unitId: unit.id,
+      grade: unit.grade,
+      subjectKey: unit.subjectKey,
+      unitNumber: unit.unitNumber,
+      titleNe: unit.titleNe,
+      transcriptionStatus: unit.transcriptionStatus,
+      notes: unit.notes ?? null,
+    },
+  });
+}
+
+const TAG_COLORS: Record<string, string> = {
+  "Grade 4": "#2563eb",
+  "Grade 5": "#7c3aed",
+  "CDC-2083": "#0f766e",
+  formative: "#ca8a04",
+  nepali: "#dc2626",
+  english: "#0284c7",
+  mathematics: "#ea580c",
+  "social-studies": "#9333ea",
+  "science-technology": "#16a34a",
+  "health-physical-creative-arts": "#db2777",
+};
+
+async function ensureTag(
+  schoolId: string,
+  departmentId: string,
+  name: string,
+  dryRun: boolean
+) {
+  const existing = await prisma.tag.findFirst({
+    where: { schoolId, name: { equals: name, mode: "insensitive" } },
+    select: { id: true, name: true },
+  });
+  if (existing) return existing;
+  if (dryRun) {
+    return { id: `dry-run-tag-${name}`, name };
+  }
+  return prisma.tag.create({
+    data: {
+      schoolId,
+      departmentId,
+      name,
+      color: TAG_COLORS[name] ?? "#3B82F6",
+    },
+    select: { id: true, name: true },
+  });
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const departmentId = String(args.departmentId ?? "");
+  if (!departmentId) {
+    console.error(
+      "Missing --departmentId=<uuid>\n\nExample:\n  npm run curriculum:import-nepal-cdc -- --departmentId=<uuid> --dry-run"
+    );
+    process.exit(1);
+  }
+
+  const dryRun = Boolean(args["dry-run"]);
+  const force = Boolean(args.force);
+  const skipBoundary = Boolean(args["skip-boundary"]);
+  const grades = String(args.grades ?? "4,5")
+    .split(",")
+    .map((g) => Number(g.trim()))
+    .filter((g): g is 4 | 5 => g === 4 || g === 5);
+  const subjectFilter = args.subjects
+    ? String(args.subjects)
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean)
+    : null;
+
+  const department = await prisma.department.findUnique({
+    where: { id: departmentId },
+    select: { id: true, name: true, schoolId: true },
+  });
+  if (!department) {
+    console.error(`Department not found: ${departmentId}`);
+    process.exit(1);
+  }
+
+  const schoolId = String(args.schoolId ?? department.schoolId);
+  if (schoolId !== department.schoolId) {
+    console.error(
+      `schoolId ${schoolId} does not match department school ${department.schoolId}`
+    );
+    process.exit(1);
+  }
+
+  const manifest = loadJson<Record<string, unknown>>(
+    join(PACK_DIR, "manifest.json")
+  );
+  const proficiency = loadJson<ProficiencyScale>(
+    join(PACK_DIR, "proficiency-scale.json")
+  );
+
+  const subjectFiles = readdirSync(join(PACK_DIR, "subjects")).filter((f) =>
+    f.endsWith(".json")
+  );
+  const subjects: SubjectFile[] = subjectFiles.map((f) =>
+    loadJson<SubjectFile>(join(PACK_DIR, "subjects", f))
+  );
+
+  const units = subjects
+    .filter((s) => !subjectFilter || subjectFilter.includes(s.key))
+    .flatMap((s) => s.units)
+    .filter((u) => grades.includes(u.grade));
+
+  console.log(`Pack: ${String(manifest.name)} (${String(manifest.version)})`);
+  console.log(
+    `Department: ${department.name} (${department.id}) @ school ${schoolId}`
+  );
+  console.log(
+    `Importing ${units.length} unit MarkSchemes` +
+      (skipBoundary ? "" : " + 1 proficiency GradingBoundary") +
+      (dryRun ? " [DRY RUN]" : "")
+  );
+
+  const existingRubrics = await prisma.markScheme.findMany({
+    where: { departmentId },
+    select: { name: true },
+  });
+  const existingNames = new Set(
+    existingRubrics.map((r) => r.name).filter(Boolean) as string[]
+  );
+
+  let createdRubrics = 0;
+  let skippedRubrics = 0;
+  let createdBoundary = 0;
+  let skippedBoundary = 0;
+  const tagCache = new Map<string, { id: string; name: string }>();
+
+  async function getTag(name: string) {
+    const hit = tagCache.get(name);
+    if (hit) return hit;
+    const tag = await ensureTag(schoolId, departmentId, name, dryRun);
+    tagCache.set(name, tag);
+    return tag;
+  }
+
+  if (!skipBoundary) {
+    const boundaryName = proficiency.gradingBoundary.name;
+    const existingBoundary = await prisma.gradingBoundary.findFirst({
+      where: { departmentId, name: boundaryName },
+      select: { id: true },
+    });
+    if (existingBoundary && !force) {
+      console.log(`Skip boundary (exists): ${boundaryName}`);
+      skippedBoundary++;
+      const tagNames = ["CDC-2083", "Grade 4", "Grade 5", "formative"];
+      for (const name of tagNames) {
+        const tag = await getTag(name);
+        if (!dryRun) {
+          await prisma.gradingBoundary.update({
+            where: { id: existingBoundary.id },
+            data: { tags: { connect: { id: tag.id } } },
+          });
+        }
+      }
+    } else if (dryRun) {
+      console.log(`Would create boundary: ${boundaryName}`);
+      createdBoundary++;
+      for (const name of ["CDC-2083", "Grade 4", "Grade 5", "formative"]) {
+        await getTag(name);
+      }
+    } else {
+      const structured = JSON.stringify({
+        name: proficiency.gradingBoundary.name,
+        boundaries: proficiency.gradingBoundary.boundaries,
+      });
+      const created = await prisma.gradingBoundary.create({
+        data: {
+          name: boundaryName,
+          structured,
+          department: { connect: { id: departmentId } },
+        },
+        select: { id: true },
+      });
+      for (const name of ["CDC-2083", "Grade 4", "Grade 5", "formative"]) {
+        const tag = await getTag(name);
+        await prisma.gradingBoundary.update({
+          where: { id: created.id },
+          data: { tags: { connect: { id: tag.id } } },
+        });
+      }
+      console.log(`Created boundary: ${boundaryName}`);
+      createdBoundary++;
+    }
+  }
+
+  for (const unit of units) {
+    const name = unit.markScheme.name;
+    if (existingNames.has(name) && !force) {
+      skippedRubrics++;
+      continue;
+    }
+
+    const structured = buildMarkSchemeStructured(unit);
+    const tagNames = Array.from(
+      new Set([
+        ...unit.tags,
+        `Grade ${unit.grade}`,
+        unit.subjectKey,
+        "CDC-2083",
+        "formative",
+      ])
+    );
+
+    if (dryRun) {
+      createdRubrics++;
+      for (const t of tagNames) await getTag(t);
+      continue;
+    }
+
+    const created = await prisma.markScheme.create({
+      data: {
+        name,
+        structured,
+        department: { connect: { id: departmentId } },
+      },
+      select: { id: true },
+    });
+
+    for (const tagName of tagNames) {
+      const tag = await getTag(tagName);
+      await prisma.markScheme.update({
+        where: { id: created.id },
+        data: { tags: { connect: { id: tag.id } } },
+      });
+    }
+
+    existingNames.add(name);
+    createdRubrics++;
+  }
+
+  console.log("\nDone.");
+  console.log(`  Rubric templates created: ${createdRubrics}`);
+  console.log(`  Rubric templates skipped: ${skippedRubrics}`);
+  console.log(`  Boundary templates created: ${createdBoundary}`);
+  console.log(`  Boundary templates skipped: ${skippedBoundary}`);
+  console.log(`  Tags ensured: ${tagCache.size}`);
+  if (dryRun) {
+    console.log("\nDry run only — no database writes.");
+  } else {
+    console.log(
+      "\nApply from Institution → Department → Templates, or class InstitutionPanel → Apply template."
+    );
+  }
+  console.log(
+    "\n⚠ Spot-check required: Nepali titles/outcomes need a Nepali-speaker review before production."
+  );
+}
+
+main()
+  .catch((err) => {
+    console.error(err);
+    process.exit(1);
+  })
+  .finally(async () => {
+    await prisma.$disconnect();
+  });

package/src/lib/assignmentTypeDefaults.ts

@@ -0,0 +1,222 @@
+import type { AssignmentType } from "@prisma/client";
+import { TRPCError } from "@trpc/server";
+
+export type AssignmentTypeBehavior = {
+  acceptFiles: boolean;
+  acceptExtendedResponse: boolean;
+  acceptWorksheet: boolean;
+  singleAttempt: boolean;
+  allowLateSubmissions: boolean;
+  timeLimitMinutes: number | null;
+};
+
+/**
+ * Sensible defaults by assignment type. QUIZ/TEST tighten attempts and
+ * discourage late file spam; ESSAY/DISCUSSION prefer written response.
+ */
+export function getAssignmentTypeDefaults(
+  type: AssignmentType | string | undefined | null
+): AssignmentTypeBehavior {
+  switch (type) {
+    case "QUIZ":
+      return {
+        acceptFiles: false,
+        acceptExtendedResponse: false,
+        acceptWorksheet: true,
+        singleAttempt: true,
+        allowLateSubmissions: false,
+        timeLimitMinutes: null,
+      };
+    case "TEST":
+      return {
+        acceptFiles: false,
+        acceptExtendedResponse: false,
+        acceptWorksheet: true,
+        singleAttempt: true,
+        allowLateSubmissions: false,
+        timeLimitMinutes: null,
+      };
+    case "ESSAY":
+      return {
+        acceptFiles: false,
+        acceptExtendedResponse: true,
+        acceptWorksheet: false,
+        singleAttempt: false,
+        allowLateSubmissions: true,
+        timeLimitMinutes: null,
+      };
+    case "DISCUSSION":
+      return {
+        acceptFiles: false,
+        acceptExtendedResponse: true,
+        acceptWorksheet: false,
+        singleAttempt: false,
+        allowLateSubmissions: true,
+        timeLimitMinutes: null,
+      };
+    case "PROJECT":
+    case "PRESENTATION":
+    case "LAB":
+      return {
+        acceptFiles: true,
+        acceptExtendedResponse: true,
+        acceptWorksheet: false,
+        singleAttempt: false,
+        allowLateSubmissions: true,
+        timeLimitMinutes: null,
+      };
+    case "HOMEWORK":
+    case "OTHER":
+    default:
+      return {
+        acceptFiles: true,
+        acceptExtendedResponse: false,
+        acceptWorksheet: false,
+        singleAttempt: false,
+        allowLateSubmissions: true,
+        timeLimitMinutes: null,
+      };
+  }
+}
+
+export type AssignmentBehaviorInput = {
+  type?: AssignmentType | string | null;
+  acceptFiles?: boolean;
+  acceptExtendedResponse?: boolean;
+  acceptWorksheet?: boolean;
+  singleAttempt?: boolean;
+  allowLateSubmissions?: boolean;
+  timeLimitMinutes?: number | null;
+  /** When true, fill unspecified deliverable/behavior flags from type defaults. */
+  applyTypeDefaults?: boolean;
+};
+
+/**
+ * Merge explicit fields with type defaults and validate incompatible combos.
+ */
+export function resolveAssignmentBehavior(input: AssignmentBehaviorInput): {
+  acceptFiles: boolean;
+  acceptExtendedResponse: boolean;
+  acceptWorksheet: boolean;
+  singleAttempt: boolean;
+  allowLateSubmissions: boolean;
+  timeLimitMinutes: number | null | undefined;
+} {
+  const defaults = getAssignmentTypeDefaults(input.type);
+  const apply = input.applyTypeDefaults !== false;
+
+  const acceptFiles =
+    input.acceptFiles !== undefined
+      ? input.acceptFiles
+      : apply
+        ? defaults.acceptFiles
+        : false;
+  const acceptExtendedResponse =
+    input.acceptExtendedResponse !== undefined
+      ? input.acceptExtendedResponse
+      : apply
+        ? defaults.acceptExtendedResponse
+        : false;
+  const acceptWorksheet =
+    input.acceptWorksheet !== undefined
+      ? input.acceptWorksheet
+      : apply
+        ? defaults.acceptWorksheet
+        : false;
+  const singleAttempt =
+    input.singleAttempt !== undefined
+      ? input.singleAttempt
+      : apply
+        ? defaults.singleAttempt
+        : false;
+  const allowLateSubmissions =
+    input.allowLateSubmissions !== undefined
+      ? input.allowLateSubmissions
+      : apply
+        ? defaults.allowLateSubmissions
+        : true;
+  const timeLimitMinutes =
+    input.timeLimitMinutes !== undefined
+      ? input.timeLimitMinutes
+      : apply
+        ? defaults.timeLimitMinutes
+        : undefined;
+
+  if (
+    timeLimitMinutes !== undefined &&
+    timeLimitMinutes !== null &&
+    (timeLimitMinutes < 1 || timeLimitMinutes > 24 * 60)
+  ) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "timeLimitMinutes must be between 1 and 1440",
+    });
+  }
+
+  // Quizzes/tests: disallow file deliverables when late submissions are off
+  // (prevents "late file spam" after the window closes).
+  if (
+    (input.type === "QUIZ" || input.type === "TEST") &&
+    acceptFiles &&
+    !allowLateSubmissions &&
+    input.acceptFiles === true
+  ) {
+    // Allowed only when teacher explicitly opts into files; keep allowLate false.
+  }
+
+  if (
+    !acceptFiles &&
+    !acceptExtendedResponse &&
+    !acceptWorksheet
+  ) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message:
+        "Assignment must accept at least one deliverable (files, extended response, or worksheet)",
+    });
+  }
+
+  return {
+    acceptFiles,
+    acceptExtendedResponse,
+    acceptWorksheet,
+    singleAttempt,
+    allowLateSubmissions,
+    timeLimitMinutes,
+  };
+}
+
+export const SIDEBAR_FEATURE_KEYS = [
+  "overview",
+  "assignments",
+  "quizzes",
+  "worksheets",
+  "grades",
+  "files",
+  "modules",
+  "discussions",
+  "attendance",
+  "aiLabs",
+  "members",
+  "syllabus",
+  "settings",
+] as const;
+
+export type SidebarFeatureKey = (typeof SIDEBAR_FEATURE_KEYS)[number];
+
+export type SidebarFeatures = Partial<Record<SidebarFeatureKey, boolean>>;
+
+export function normalizeSidebarFeatures(
+  value: unknown
+): SidebarFeatures | null {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  const out: SidebarFeatures = {};
+  for (const key of SIDEBAR_FEATURE_KEYS) {
+    if (key in (value as object)) {
+      out[key] = Boolean((value as Record<string, unknown>)[key]);
+    }
+  }
+  return out;
+}

package/src/lib/config/env.ts

@@ -69,8 +69,6 @@ const fullSchema = baseSchema.extend({
   INFERENCE_API_BASE_URL: z.string().url().optional(),
   OPENAI_API_KEY: z.string().optional(),
   LOG_MODE: z.enum(['normal', 'verbose', 'quiet']).default('normal'),
-  /** Comma/whitespace-separated user UUIDs allowed to call `admin.*` tRPC (required in production). */
-  ADMIN_PANEL_USER_IDS: z.string().optional(),
 });
 
 // Test schema - only require what's needed for tests
@@ -99,7 +97,6 @@ const testSchema = baseSchema.extend({
   OPENAI_API_KEY: z.string().optional(),
   INFERENCE_API_BASE_URL: z.string().url().optional(),
   LOG_MODE: z.enum(['normal', 'verbose', 'quiet']).default('quiet'),
-  ADMIN_PANEL_USER_IDS: z.string().optional(),
 });
 
 // Use test schema in test mode, full schema otherwise