Auto-formatted the code using Prettier

Author: kevin-lann

course-matrix/backend/__tests__/analyzeQuery.test.ts

@@ -91,7 +91,7 @@ describe("analyzeQuery", () => {
 
   test("should detect multiple namespaces in a single query", () => {
     const result = analyzeQuery(
-      "What are the prerequisites and schedule for CSC108?"
+      "What are the prerequisites and schedule for CSC108?",
     );
     expect(result.requiresSearch).toBe(true);
     expect(result.relevantNamespaces).toContain("prerequisites");

course-matrix/backend/__tests__/includeFilters.test.ts

@@ -1,131 +1,124 @@
 import {
   BREADTH_REQUIREMENT_KEYWORDS,
-  YEAR_LEVEL_KEYWORDS
-} from '../src/constants/promptKeywords'; 
-import { includeFilters } from '../src/utils/includeFilters';
+  YEAR_LEVEL_KEYWORDS,
+} from "../src/constants/promptKeywords";
+import { includeFilters } from "../src/utils/includeFilters";
 import { describe, test, expect, jest, beforeEach } from "@jest/globals";
-import * as ModuleType from '../src/utils/convert-breadth-requirement';
-import * as ModuleType0 from '../src/utils/convert-year-level';
+import * as ModuleType from "../src/utils/convert-breadth-requirement";
+import * as ModuleType0 from "../src/utils/convert-year-level";
 
 // Create mock functions
-const mockConvertBreadthRequirement = jest.fn((namespace) => `converted_${namespace}`);
+const mockConvertBreadthRequirement = jest.fn(
+  (namespace) => `converted_${namespace}`,
+);
 const mockConvertYearLevel = jest.fn((namespace) => `converted_${namespace}`);
 
 // Mock the modules
-jest.mock('../src/utils/convert-breadth-requirement', () => ({
-  convertBreadthRequirement: (namespace: string) => mockConvertBreadthRequirement(namespace)
+jest.mock("../src/utils/convert-breadth-requirement", () => ({
+  convertBreadthRequirement: (namespace: string) =>
+    mockConvertBreadthRequirement(namespace),
 }));
 
-jest.mock('../src/utils/convert-year-level', () => ({
-  convertYearLevel: (namespace: string) => mockConvertYearLevel(namespace)
+jest.mock("../src/utils/convert-year-level", () => ({
+  convertYearLevel: (namespace: string) => mockConvertYearLevel(namespace),
 }));
 
-describe('includeFilters', () => {
+describe("includeFilters", () => {
   beforeEach(() => {
     // Clear mock data before each test
     mockConvertBreadthRequirement.mockClear();
     mockConvertYearLevel.mockClear();
   });
 
-  test('should return empty object when no filters match', () => {
-    const query = 'something random';
+  test("should return empty object when no filters match", () => {
+    const query = "something random";
     const result = includeFilters(query);
     expect(result).toEqual({});
   });
 
-  test('should match breadth requirement keywords case-insensitively', () => {
-    const query = 'I want to study ART Literature';
+  test("should match breadth requirement keywords case-insensitively", () => {
+    const query = "I want to study ART Literature";
     const result = includeFilters(query);
     expect(result).toEqual({
-      $or: [
-        { breadth_requirement: { $eq: 'converted_ART_LIT_LANG' } }
-      ]
+      $or: [{ breadth_requirement: { $eq: "converted_ART_LIT_LANG" } }],
     });
   });
 
-  test('should match year level keywords case-insensitively', () => {
-    const query = 'Looking for A-level courses';
+  test("should match year level keywords case-insensitively", () => {
+    const query = "Looking for A-level courses";
     const result = includeFilters(query);
     expect(result).toEqual({
-      $or: [
-        { year_level: { $eq: 'converted_first_year' } }
-      ]
+      $or: [{ year_level: { $eq: "converted_first_year" } }],
     });
   });
 
-  test('should combine both breadth and year level filters with $and when both are present', () => {
-    const query = 'Natural Science First-Year courses';
+  test("should combine both breadth and year level filters with $and when both are present", () => {
+    const query = "Natural Science First-Year courses";
     const result = includeFilters(query);
     expect(result).toEqual({
       $and: [
         {
-          $or: [
-            { breadth_requirement: { $eq: 'converted_NAT_SCI' } }
-          ]
+          $or: [{ breadth_requirement: { $eq: "converted_NAT_SCI" } }],
         },
         {
-          $or: [
-            { year_level: { $eq: 'converted_first_year' } }
-          ]
-        }
-      ]
+          $or: [{ year_level: { $eq: "converted_first_year" } }],
+        },
+      ],
     });
   });
 
-  test('should handle multiple breadth requirements', () => {
-    const query = 'social science or quantitative reasoning';
+  test("should handle multiple breadth requirements", () => {
+    const query = "social science or quantitative reasoning";
     const result = includeFilters(query);
     expect(result).toEqual({
       $or: [
-        { breadth_requirement: { $eq: 'converted_SOCIAL_SCI' } },
-        { breadth_requirement: { $eq: 'converted_QUANT' } }
-      ]
+        { breadth_requirement: { $eq: "converted_SOCIAL_SCI" } },
+        { breadth_requirement: { $eq: "converted_QUANT" } },
+      ],
     });
   });
 
-  test('should handle multiple year levels', () => {
-    const query = 'third year or fourth-year courses';
+  test("should handle multiple year levels", () => {
+    const query = "third year or fourth-year courses";
     const result = includeFilters(query);
     expect(result).toEqual({
       $or: [
-        { year_level: { $eq: 'converted_third_year' } },
-        { year_level: { $eq: 'converted_fourth_year' } }
-      ]
+        { year_level: { $eq: "converted_third_year" } },
+        { year_level: { $eq: "converted_fourth_year" } },
+      ],
     });
   });
 
-  test('should handle multiple breadth requirements and year levels', () => {
-    const query = 'history philosophy B-level or C-level';
+  test("should handle multiple breadth requirements and year levels", () => {
+    const query = "history philosophy B-level or C-level";
     const result = includeFilters(query);
-    console.log(result)
+    console.log(result);
     expect(result).toEqual({
       $and: [
         {
-          $or: [
-            { breadth_requirement: { $eq: 'converted_HIS_PHIL_CUL' } }
-          ]
+          $or: [{ breadth_requirement: { $eq: "converted_HIS_PHIL_CUL" } }],
         },
         {
           $or: [
-            { year_level: { $eq: 'converted_second_year' } },
-            { year_level: { $eq: 'converted_third_year' } }
-          ]
-        }
-      ]
+            { year_level: { $eq: "converted_second_year" } },
+            { year_level: { $eq: "converted_third_year" } },
+          ],
+        },
+      ],
     });
   });
 
-  test('should ignore partial keyword matches', () => {
+  test("should ignore partial keyword matches", () => {
     // "art" alone shouldn't match "art literature language"
-    const query = 'art courses';
+    const query = "art courses";
     const result = includeFilters(query);
     // This should not match any specific filter since "art" alone isn't in the keywords
     expect(result).toEqual({});
   });
 
-  test('should handle edge case with empty query', () => {
-    const query = '';
+  test("should handle edge case with empty query", () => {
+    const query = "";
     const result = includeFilters(query);
     expect(result).toEqual({});
   });
-});
+});

course-matrix/backend/src/utils/analyzeQuery.ts

@@ -57,7 +57,7 @@ export function analyzeQuery(query: string): {
       "prerequisites",
       "corequisites",
       "departments",
-      "programs"
+      "programs",
     );
   }
 

course-matrix/backend/src/utils/includeFilters.ts

@@ -16,7 +16,7 @@ export function includeFilters(query: string) {
       if (keywords.some((keyword) => lowerQuery.includes(keyword))) {
         relaventBreadthRequirements.push(convertBreadthRequirement(namespace));
       }
-    }
+    },
   );
 
   Object.entries(YEAR_LEVEL_KEYWORDS).forEach(([namespace, keywords]) => {