Added auxillary methods to allow for CRUD of composite audits.

Author: spotta85

lib/backend/storage.ts

@@ -5,6 +5,8 @@ import { browser } from "wxt/browser";
 import type {
   AuditHistoryData,
   CachedAuditData,
+  CachedCompositeAudit,
+  CompositeAuditData,
   CourseId,
   DegreeAuditCardProps,
   PlannedCourseOutline,
@@ -285,3 +287,118 @@ export async function getUncachedAuditIds(
   }
   return uncached;
 }
+
+/**
+ * Helper function: Loads each saved audit from the per-audit cache and combines them into the
+ * composite model. IDs with no cached data (never scraped or failed to scrape)
+ * are skipped, so the remaining audits still load. Display names come from audit
+ * history, matching the provider's naming logic.
+ *
+ * @param auditIds - The IDs of the audits to load and combine.
+ * @returns A composite holding one entry per successfully loaded audit.
+ */
+export async function loadCompositeAuditData(
+  auditIds: string[],
+  options?: {
+    // Injectable for tests; defaults to the real storage readers.
+    getData?: (id: string) => Promise<CachedAuditData | null>;
+    getHistory?: () => Promise<AuditHistoryData | null>;
+  },
+): Promise<CompositeAuditData> {
+  const getData = options?.getData ?? getAuditData;
+  const getHistory = options?.getHistory ?? getAuditHistory;
+
+  const history = await getHistory();
+  const audits: CachedAuditData[] = [];
+
+  for (const id of auditIds) {
+    const data = await getData(id);
+    if (!data) continue; // not cached yet — skip so the others still load
+    const card = history?.audits.find((a) => a.auditId === id);
+    const name = card?.title ?? card?.majors?.join("; ") ?? id;
+    audits.push({ ...data, name });
+  }
+
+  return { audits };
+}
+
+// ---- Saved Composites (a named grouping of audits the user views together) ----
+const COMPOSITES_KEY = "compositeAudits";
+
+// Get all saved composites (returns an empty list if none).
+export async function getCachedComposites(): Promise<CachedCompositeAudit[]> {
+  try {
+    const result = await browser.storage.local.get(COMPOSITES_KEY);
+    return (result[COMPOSITES_KEY] as CachedCompositeAudit[]) ?? [];
+  } catch (e) {
+    console.error("Failed to get composites from storage:", e);
+    return [];
+  }
+}
+
+async function setCachedComposites(
+  composites: CachedCompositeAudit[],
+): Promise<void> {
+  await browser.storage.local.set({ [COMPOSITES_KEY]: composites });
+}
+
+/**
+ * Creates a new composite from a set of audits, frontend facing method  "create
+ * composite" audit. Persists only the name + member ids, then builds and
+ * returns the composite so the caller can render it immediately without a second
+ * round-trip.
+ *
+ * @param name - The user-facing label for the composite.
+ * @param auditIds - The IDs of the audits that make up the composite.
+ * @returns The stored record and the freshly built composite.
+ */
+export async function createComposite(
+  name: string,
+  auditIds: string[],
+): Promise<{ saved: CachedCompositeAudit; composite: CompositeAuditData }> {
+  const saved: CachedCompositeAudit = {
+    id: crypto.randomUUID(),
+    name,
+    auditIds,
+  };
+  const composites = await getCachedComposites();
+  await setCachedComposites([...composites, saved]);
+  const composite = await loadCompositeAuditData(auditIds);
+  return { saved, composite };
+}
+
+
+export async function updateCachedComposite(
+  id: string,
+  patch: Partial<Pick<CachedCompositeAudit, "name" | "auditIds">>,
+): Promise<CachedCompositeAudit | null> {
+  const composites = await getCachedComposites();
+  const existing = composites.find((c) => c.id === id);
+  if (!existing) return null;
+  const updated: CachedCompositeAudit = { ...existing, ...patch, id };
+  await setCachedComposites(composites.map((c) => (c.id === id ? updated : c)));
+  return updated;
+}
+
+export async function deleteCachedComposite(id: string): Promise<boolean> {
+  const composites = await getCachedComposites();
+  const next = composites.filter((c) => c.id !== id);
+  if (next.length === composites.length) return false;
+  await setCachedComposites(next);
+  return true;
+}
+
+/**
+ * Reopens a saved composite by rebuilding it from the per-audit cache.
+ *
+ * @param id - The ID of the composite to load.
+ * @returns The built composite, or null if no composite has that ID.
+ */
+export async function loadCompositeAudit(
+  id: string,
+): Promise<CompositeAuditData | null> {
+  const composites = await getCachedComposites();
+  const composite = composites.find((c) => c.id === id);
+  if (!composite) return null;
+  return loadCompositeAuditData(composite.auditIds);
+}

lib/general-types.ts

@@ -50,6 +50,15 @@ export interface CompositeAuditData {
   audits: CachedAuditData[];
 }
 
+// A persisted composite. Stores only a name + the member audit ids; it does NOT cache audit
+// data. The full CompositeAuditData is rebuilt on demand from the per-audit cache
+// (auditData_<id>) so it never goes stale when planned courses change or audits re-scrape.
+export interface CachedCompositeAudit {
+  id: string; // crypto.randomUUID()
+  name: string; // user-facing label, e.g. "My Degree Plan"
+  auditIds: string[]; // ordered member ids -> point into auditData_<id>
+}
+
 /**
  * Simple way of expanding an object type one layer so it shows its children's contents
  */

package.json

@@ -14,6 +14,8 @@
     "compile": "bun run tsc --noEmit",
     "test:parse-major": "bun run tests/validate-parse-major.ts",
     "test:requirement-progress": "bun run tests/validate-requirement-progress.ts",
+    "test:composite-load": "bun run tests/validate-composite-audit-load.ts",
+    "test:saved-composites": "bun run tests/validate-saved-composites.ts",
     "postinstall": "bun run wxt prepare",
     "prepare": "husky",
     "tailwind:init": "bun run tailwindcss init -p"

tests/validate-composite-audit-load.ts

@@ -0,0 +1,159 @@
+import assert from "node:assert/strict";
+import {
+  getCompositeAuditRequirements,
+  getDuplicateCourseRequirementFlags,
+} from "../lib/audit-calculations";
+import { loadCompositeAuditData } from "../lib/backend/storage";
+import type { AuditHistoryData, CachedAuditData } from "../lib/general-types";
+
+// --- Fixtures ---------------------------------------------------------------
+
+// Two audits that share a course code (M 341) so the composite helpers have a
+// duplicate to flag once the audits are combined.
+const csAudit: CachedAuditData = {
+  requirements: [
+    {
+      title: "Major Requirements",
+      rules: [
+        {
+          text: "Linear Algebra",
+          requiredHours: 3,
+          appliedHours: 3,
+          remainingHours: 0,
+          progressUnit: "hours",
+          status: "Completed",
+          courses: ["cs-linear-algebra"],
+        },
+      ],
+    },
+  ],
+  courses: {
+    "cs-linear-algebra": {
+      id: "cs-linear-algebra",
+      code: "M 341",
+      name: "Linear Algebra",
+      hours: 3,
+      semester: "Fall 2026",
+      status: "Completed",
+      type: "In-Residence",
+    },
+  },
+};
+
+const mathMinorAudit: CachedAuditData = {
+  requirements: [
+    {
+      title: "Minor Requirements",
+      rules: [
+        {
+          text: "Linear Algebra",
+          requiredHours: 3,
+          appliedHours: 3,
+          remainingHours: 0,
+          progressUnit: "hours",
+          status: "Completed",
+          courses: ["minor-linear-algebra"],
+        },
+      ],
+    },
+  ],
+  courses: {
+    "minor-linear-algebra": {
+      id: "minor-linear-algebra",
+      code: "M 341",
+      name: "Linear Algebra",
+      hours: 3,
+      semester: "Fall 2026",
+      status: "Completed",
+      type: "In-Residence",
+    },
+  },
+};
+
+const cache: Record<string, CachedAuditData> = {
+  "audit-cs": csAudit,
+  "audit-math-minor": mathMinorAudit,
+};
+
+const history: AuditHistoryData = {
+  audits: [
+    {
+      auditId: "audit-cs",
+      title: "Computer Science BS",
+      majors: ["Computer Science"],
+    },
+    {
+      auditId: "audit-math-minor",
+      majors: ["Mathematics"],
+      minors: ["Mathematics"],
+    },
+  ],
+  timestamp: 0,
+};
+
+const mockGetData = (id: string) => Promise.resolve(cache[id] ?? null);
+const mockGetHistory = () => Promise.resolve(history);
+
+// --- Tests ------------------------------------------------------------------
+
+// Combines multiple saved audits into the composite (AC #2).
+{
+  const composite = await loadCompositeAuditData(
+    ["audit-cs", "audit-math-minor"],
+    { getData: mockGetData, getHistory: mockGetHistory },
+  );
+
+  assert.equal(composite.audits.length, 2);
+  // Name resolves from history title, then majors, then the raw id.
+  assert.equal(composite.audits[0].name, "Computer Science BS");
+  assert.equal(composite.audits[1].name, "Mathematics");
+}
+
+// Falls back to the raw id when history has no entry for the audit.
+{
+  const composite = await loadCompositeAuditData(["audit-cs"], {
+    getData: mockGetData,
+    getHistory: () => Promise.resolve(null),
+  });
+
+  assert.equal(composite.audits.length, 1);
+  assert.equal(composite.audits[0].name, "audit-cs");
+}
+
+// Skips uncached IDs so the remaining audits still load (AC #3, #4).
+{
+  const composite = await loadCompositeAuditData(
+    ["audit-cs", "missing-audit", "audit-math-minor"],
+    { getData: mockGetData, getHistory: mockGetHistory },
+  );
+
+  assert.equal(composite.audits.length, 2);
+  assert.deepEqual(
+    composite.audits.map((a) => a.name),
+    ["Computer Science BS", "Mathematics"],
+  );
+}
+
+// The combined composite is consumed correctly by the 6.1 helpers.
+{
+  const composite = await loadCompositeAuditData(
+    ["audit-cs", "audit-math-minor"],
+    { getData: mockGetData, getHistory: mockGetHistory },
+  );
+
+  const compositeRequirements = getCompositeAuditRequirements(composite);
+  const duplicateFlags = getDuplicateCourseRequirementFlags(composite);
+
+  assert.equal(compositeRequirements.length, 2);
+  assert.deepEqual(compositeRequirements[0].duplicateCourseCodes, ["M 341"]);
+  assert.deepEqual(compositeRequirements[1].duplicateCourseCodes, ["M 341"]);
+
+  assert.equal(duplicateFlags.length, 1);
+  assert.equal(duplicateFlags[0].courseCode, "M 341");
+  assert.deepEqual(duplicateFlags[0].auditNames, [
+    "Computer Science BS",
+    "Mathematics",
+  ]);
+}
+
+console.log("Composite audit load validation passed.");