Logic engine v2 (#1123)

* Revert "Revert "Logic engine (#1030)""

This reverts commit fa48909.

* lint

Author: ARtheboss

.cursorrules

@@ -95,6 +95,7 @@ src/
 - Use SCSS Modules (`.module.scss`) for component styles
 - Use Bootstrap utility classes (`m-*`, `p-*`) for simple spacing when appropriate
 - Import styles: `import styles from "./Component.module.scss"`
+- Use `classNames` utility (or similar) when combining classes instead of manual string manipulation (e.g., `classNames(styles.base, { [styles.active]: isActive })` instead of `styles.base + (isActive ? ' ' + styles.active : '')`)
 - Use/extend `@repo/theme` components when available instead of building custom ones
 
 ### File Naming

apps/backend/src/modules/course/formatter.ts

@@ -5,6 +5,7 @@ import { CourseModule } from "./generated-types/module-types";
 
 interface CourseRelationships {
   classes: null;
+  mostRecentClass: null;
   gradeDistribution: null;
   crossListing: string[];
   requiredCourses: string[];
@@ -31,6 +32,7 @@ export function formatCourse(course: ICourseItem) {
     finalExam: course.finalExam as CourseModule.CourseFinalExam,
 
     classes: null,
+    mostRecentClass: null,
     gradeDistribution: null,
     crossListing: course.crossListing ?? [],
     requiredCourses: course.preparation?.requiredCourses ?? [],

apps/backend/src/modules/course/resolver.ts

@@ -156,6 +156,24 @@ const resolvers: CourseModule.Resolvers = {
       return classes.filter(matchesCourse) as unknown as CourseModule.Class[];
     },
 
+    mostRecentClass: async (
+      parent: IntermediateCourse | CourseModule.Course
+    ) => {
+      const classes = parent.classes
+        ? null
+        : await getClassesByCourse(parent.courseId);
+
+      return (parent.classes ?? classes)!.toSorted((a, b) => {
+        if (a.year === b.year) {
+          return (
+            (SEMESTER_RECENCY_ORDER[a.semester ?? ""] ?? -1) -
+            (SEMESTER_RECENCY_ORDER[b.semester ?? ""] ?? -1)
+          );
+        }
+        return b.year - a.year;
+      })[0] as unknown as CourseModule.Class;
+    },
+
     crossListing: async (parent: IntermediateCourse | CourseModule.Course) => {
       // cross listings are stored as `${subject} ${number}`
 

apps/backend/src/modules/plan/controller.ts

@@ -3,20 +3,24 @@ import { Types } from "mongoose";
 
 import {
   LabelModel,
-  MajorReqModel,
   PlanModel,
+  PlanRequirementModel,
   PlanTermModel,
   SelectedCourseModel,
+  SelectedPlanRequirementModel,
 } from "@repo/common/models";
 
 import {
   Colleges,
   EditPlanTermInput,
   Plan,
   PlanInput,
+  PlanRequirement,
   PlanTerm,
   PlanTermInput,
   SelectedCourseInput,
+  SelectedPlanRequirementInput,
+  UpdateManualOverrideInput,
 } from "../../generated-types/graphql";
 import { RequestContext } from "../../types/request-context";
 import { formatPlan, formatPlanTerm } from "./formatter";
@@ -238,20 +242,43 @@ export async function createPlan(
     })
   );
 
+  const selectedPlanRequirements = await buildSelectedPlanRequirementsForPlan(
+    majors,
+    minors,
+    colleges.map((c) => String(c))
+  );
+
   const newPlan = await PlanModel.create({
     userEmail,
     planTerms: planTerms,
     majors: majors,
     minors: minors,
-    majorReqs: [],
     colleges: colleges,
     labels: [],
-    uniReqsSatisfied: [],
-    collegeReqsSatisfied: [],
+    selectedPlanRequirements: selectedPlanRequirements.map(
+      (spr) =>
+        new SelectedPlanRequirementModel({
+          planRequirementId: new Types.ObjectId(spr.planRequirementId),
+          manualOverrides: spr.manualOverrides,
+        })
+    ),
   });
   return formatPlan(newPlan);
 }
 
+/** Build selectedPlanRequirements for given majors, minors, colleges (UC + college + major/minor). Used by createPlan, editPlan sync, and migrations. */
+export async function buildSelectedPlanRequirementsForPlan(
+  majors: string[],
+  minors: string[],
+  colleges: string[]
+): Promise<SelectedPlanRequirementInput[]> {
+  const reqs = await getRequiredPlanRequirements(majors, minors, colleges);
+  return reqs.map((r) => ({
+    planRequirementId: r._id,
+    manualOverrides: [],
+  }));
+}
+
 export async function editPlan(
   plan: PlanInput,
   context: RequestContext
@@ -263,6 +290,10 @@ export async function editPlan(
     throw new Error("No Plan found for this user");
   }
 
+  const majorsChanged = plan.majors != null;
+  const minorsChanged = plan.minors != null;
+  const collegesChanged = plan.colleges != null;
+
   if (plan.colleges != null) {
     gt.colleges = plan.colleges;
   }
@@ -272,19 +303,32 @@ export async function editPlan(
   if (plan.minors != null) {
     gt.minors = plan.minors;
   }
-  if (plan.majorReqs != null) {
-    gt.majorReqs = plan.majorReqs.map(
-      (majorReqInput) => new MajorReqModel(majorReqInput)
-    );
-  }
   if (plan.labels != null) {
     gt.labels = plan.labels.map((labelInput) => new LabelModel(labelInput));
   }
-  if (plan.uniReqsSatisfied != null) {
-    gt.uniReqsSatisfied = plan.uniReqsSatisfied;
-  }
-  if (plan.collegeReqsSatisfied != null) {
-    gt.collegeReqsSatisfied = plan.collegeReqsSatisfied;
+
+  if (majorsChanged || minorsChanged || collegesChanged) {
+    const wantedReqs = await getRequiredPlanRequirements(
+      gt.majors,
+      gt.minors,
+      gt.colleges
+    );
+    const wantedIds = new Set(wantedReqs.map((r) => r._id));
+    const currentIds = new Set(
+      gt.selectedPlanRequirements.map((spr) => spr.planRequirementId.toString())
+    );
+    const kept = gt.selectedPlanRequirements.filter((spr) =>
+      wantedIds.has(spr.planRequirementId.toString())
+    );
+    const newReqs = wantedReqs.filter((r) => !currentIds.has(r._id));
+    const newSprs = newReqs.map(
+      (r) =>
+        new SelectedPlanRequirementModel({
+          planRequirementId: new Types.ObjectId(r._id),
+          manualOverrides: [],
+        })
+    );
+    gt.selectedPlanRequirements = [...kept, ...newSprs];
   }
 
   await gt.save();
@@ -297,3 +341,177 @@ export async function deletePlan(context: RequestContext): Promise<string> {
   await PlanModel.deleteOne({ userEmail });
   return userEmail;
 }
+
+// Internal: get all PlanRequirement IDs that should be selected for given majors, minors, colleges (UC + college + major/minor). Deduped by _id.
+export async function getRequiredPlanRequirements(
+  majors: string[],
+  minors: string[],
+  colleges: string[]
+): Promise<PlanRequirement[]> {
+  const byId = new Map<string, PlanRequirement>();
+  const add = (req: PlanRequirement) => byId.set(req._id, req);
+
+  const uc = await getUcRequirements();
+  uc.forEach(add);
+  for (const college of colleges) {
+    const coll = await getCollegeRequirements(college);
+    coll.forEach(add);
+  }
+  const mm = await getPlanRequirementsByMajorsAndMinors(majors, minors);
+  mm.forEach(add);
+  return Array.from(byId.values());
+}
+
+// Get PlanRequirements by majors and minors (internal use)
+export async function getPlanRequirementsByMajorsAndMinors(
+  majors: string[],
+  minors: string[]
+): Promise<PlanRequirement[]> {
+  const requirements = await PlanRequirementModel.find({
+    $or: [{ major: { $in: majors } }, { minor: { $in: minors } }],
+  });
+
+  return requirements.map((req) => ({
+    _id: (req._id as Types.ObjectId).toString(),
+    code: req.code,
+    name: req.name,
+    isUcReq: req.isUcReq,
+    college: req.college || null,
+    major: req.major || null,
+    minor: req.minor || null,
+    createdBy: req.createdBy,
+    isOfficial: req.isOfficial,
+    createdAt: req.createdAt?.toISOString() || "",
+    updatedAt: req.updatedAt?.toISOString() || "",
+  }));
+}
+
+// Get UC requirements
+export async function getUcRequirements(): Promise<PlanRequirement[]> {
+  const requirements = await PlanRequirementModel.find({ isUcReq: true });
+
+  return requirements.map((req) => ({
+    _id: (req._id as Types.ObjectId).toString(),
+    code: req.code,
+    name: req.name,
+    isUcReq: req.isUcReq,
+    college: req.college || null,
+    major: req.major || null,
+    minor: req.minor || null,
+    createdBy: req.createdBy,
+    isOfficial: req.isOfficial,
+    createdAt: req.createdAt?.toISOString() || "",
+    updatedAt: req.updatedAt?.toISOString() || "",
+  }));
+}
+
+// Get college requirements
+export async function getCollegeRequirements(
+  college: string
+): Promise<PlanRequirement[]> {
+  const requirements = await PlanRequirementModel.find({ college });
+
+  return requirements.map((req) => ({
+    _id: (req._id as Types.ObjectId).toString(),
+    code: req.code,
+    name: req.name,
+    isUcReq: req.isUcReq,
+    college: req.college || null,
+    major: req.major || null,
+    minor: req.minor || null,
+    createdBy: req.createdBy,
+    isOfficial: req.isOfficial,
+    createdAt: req.createdAt?.toISOString() || "",
+    updatedAt: req.updatedAt?.toISOString() || "",
+  }));
+}
+
+// Get PlanRequirement by ID
+export async function getPlanRequirementById(
+  id: string
+): Promise<PlanRequirement | null> {
+  const requirement = await PlanRequirementModel.findById(id);
+  if (!requirement) {
+    return null;
+  }
+
+  return {
+    _id: (requirement._id as Types.ObjectId).toString(),
+    code: requirement.code,
+    name: requirement.name,
+    isUcReq: requirement.isUcReq,
+    college: requirement.college || null,
+    major: requirement.major || null,
+    minor: requirement.minor || null,
+    createdBy: requirement.createdBy,
+    isOfficial: requirement.isOfficial,
+    createdAt: requirement.createdAt?.toISOString() || "",
+    updatedAt: requirement.updatedAt?.toISOString() || "",
+  };
+}
+
+// Update manual override for a specific requirement
+export async function updateManualOverride(
+  input: UpdateManualOverrideInput,
+  context: RequestContext
+): Promise<Plan> {
+  if (!context.user?.email) throw new Error("Unauthorized");
+  const userEmail = context.user.email;
+
+  const gt = await PlanModel.findOne({ userEmail });
+  if (!gt) {
+    throw new Error("No Plan found for this user");
+  }
+
+  // Find the selectedPlanRequirement
+  const sprIndex = gt.selectedPlanRequirements.findIndex(
+    (spr) => spr.planRequirementId.toString() === input.planRequirementId
+  );
+
+  if (sprIndex === -1) {
+    throw new Error("SelectedPlanRequirement not found in user's plan");
+  }
+
+  // Update the manual override at the specified index
+  const spr = gt.selectedPlanRequirements[sprIndex];
+  if (
+    input.requirementIndex < 0 ||
+    input.requirementIndex >= spr.manualOverrides.length
+  ) {
+    // Extend the array if needed
+    while (spr.manualOverrides.length <= input.requirementIndex) {
+      spr.manualOverrides.push(null);
+    }
+  }
+  // Store null when clearing override so it persists correctly in MongoDB
+  spr.manualOverrides[input.requirementIndex] =
+    input.manualOverride !== undefined ? input.manualOverride : null;
+
+  await gt.save();
+  return formatPlan(gt);
+}
+
+// Update all selectedPlanRequirements
+export async function updateSelectedPlanRequirements(
+  selectedPlanRequirements: SelectedPlanRequirementInput[],
+  context: RequestContext
+): Promise<Plan> {
+  if (!context.user?.email) throw new Error("Unauthorized");
+  const userEmail = context.user.email;
+
+  const gt = await PlanModel.findOne({ userEmail });
+  if (!gt) {
+    throw new Error("No Plan found for this user");
+  }
+
+  gt.selectedPlanRequirements = selectedPlanRequirements.map(
+    (spr) =>
+      new SelectedPlanRequirementModel({
+        planRequirementId: new Types.ObjectId(spr.planRequirementId),
+        manualOverrides: spr.manualOverrides,
+      })
+  );
+
+  await gt.save();
+  return formatPlan(gt);
+}