Merge pull request #44 from Sajith15/feature/trie-search-suggestions

feat: implement trie-based search auto-suggestions

Author: khemssharma

server/__tests__/trie.test.js

@@ -0,0 +1,46 @@
+const Trie = require("../utils/trie");
+
+describe("Trie", () => {
+  let trie;
+
+  beforeEach(() => {
+    trie = new Trie();
+  });
+
+  it("returns empty array for unknown prefix", () => {
+    trie.insert("React Basics", { type: "course", id: "1" });
+    expect(trie.search("vue")).toEqual([]);
+  });
+
+  it("finds suggestions by prefix (case-insensitive)", () => {
+    trie.insert("React Basics", { type: "course", id: "1", courseId: "1" });
+    trie.insert("Reading Skills", { type: "course", id: "2", courseId: "2" });
+
+    const results = trie.search("rea");
+    expect(results).toHaveLength(2);
+    expect(results.map((r) => r.label)).toEqual(
+      expect.arrayContaining(["React Basics", "Reading Skills"])
+    );
+  });
+
+  it("deduplicates entries with the same type and id", () => {
+    trie.insert("React", { type: "course", id: "1", courseId: "1" });
+    trie.insert("react", { type: "course", id: "1", courseId: "1" });
+
+    expect(trie.search("re")).toHaveLength(1);
+  });
+
+  it("respects the result limit", () => {
+    trie.insert("Alpha", { type: "course", id: "1" });
+    trie.insert("Apple", { type: "course", id: "2" });
+    trie.insert("Application", { type: "course", id: "3" });
+
+    expect(trie.search("a", 2)).toHaveLength(2);
+  });
+
+  it("clears all entries", () => {
+    trie.insert("Node.js", { type: "course", id: "1" });
+    trie.clear();
+    expect(trie.search("node")).toEqual([]);
+  });
+});

server/controllers/Course.js

@@ -6,6 +6,13 @@ const User = require("../models/User")
 const { uploadImageToCloudinary } = require("../utils/imageUploader")
 const CourseProgress = require("../models/CourseProgress")
 const { convertSecondsToDuration } = require("../utils/secToDuration")
+const searchIndex = require("../services/searchIndex")
+
+const refreshSearchIndex = () => {
+  searchIndex.rebuild().catch((err) => {
+    console.error("[SearchIndex] Rebuild failed:", err.message)
+  })
+}
 // Function to create a new course
 exports.createCourse = async (req, res) => {
   try {
@@ -115,6 +122,7 @@ exports.createCourse = async (req, res) => {
       { new: true }
     )
     console.log("HEREEEEEEEE", categoryDetails2)
+    refreshSearchIndex()
     // Return the new course and a success message
     res.status(200).json({
       success: true,
@@ -185,6 +193,7 @@ exports.editCourse = async (req, res) => {
       })
       .exec()
 
+    refreshSearchIndex()
     res.json({
       success: true,
       message: "Course updated successfully",
@@ -477,6 +486,7 @@ exports.deleteCourse = async (req, res) => {
     // Delete the course
     await Course.findByIdAndDelete(courseId)
 
+    refreshSearchIndex()
     return res.status(200).json({
       success: true,
       message: "Course deleted successfully",
@@ -491,6 +501,36 @@ exports.deleteCourse = async (req, res) => {
   }
 }
 
+// Trie-backed search auto-suggestions
+exports.getSearchSuggestions = async (req, res) => {
+  try {
+    const { query, limit } = req.query;
+    const trimmedQuery = (query || "").trim();
+
+    if (!trimmedQuery) {
+      return res.status(200).json({
+        success: true,
+        data: [],
+      });
+    }
+
+    const maxResults = Math.min(parseInt(limit, 10) || 8, 20);
+    const suggestions = searchIndex.getSuggestions(trimmedQuery, maxResults);
+
+    return res.status(200).json({
+      success: true,
+      data: suggestions,
+    });
+  } catch (error) {
+    console.error(error);
+    return res.status(500).json({
+      success: false,
+      message: "Failed to fetch search suggestions",
+      error: error.message,
+    });
+  }
+};
+
 // Search Courses by query (including instructor name)
 exports.searchCourse = async (req, res) => {
   try {

server/index.js

@@ -55,6 +55,7 @@ const aiRoutes        = require("./routes/AI");
 // ── Infrastructure ────────────────────────────────────────────────────
 const database           = require("./config/database");
 const { cloudinaryConnect } = require("./config/cloudinary");
+const searchIndex        = require("./services/searchIndex");
 
 const app  = express();
 const PORT = process.env.PORT || 4000;
@@ -100,7 +101,15 @@ if (process.env.NODE_ENV !== "test") {
   const mongoose = require("mongoose");
   mongoose
     .connect(process.env.MONGODB_URL, mongooseOptions)
-    .then(() => console.log("DB Connected Successfully"))
+    .then(async () => {
+      console.log("DB Connected Successfully");
+      try {
+        const count = await searchIndex.rebuild();
+        console.log(`[SearchIndex] Indexed ${count} published courses`);
+      } catch (err) {
+        console.error("[SearchIndex] Initial build failed:", err.message);
+      }
+    })
     .catch((err) => {
       console.error("DB Connection Failed:", err);
       process.exit(1);

server/routes/Course.js

@@ -9,6 +9,9 @@ const {
   editCourse,
   deleteCourse,
   getInstructorCourses,
+  searchCourse,
+  getSearchSuggestions,
+  instructorDetails,
 } = require("../controllers/Course");
 
 const {
@@ -55,6 +58,11 @@ const {
 // Works for guests (no token) and logged-in students (personalised)
 router.get("/recommendations", optionalAuth, getRecommendations);
 
+// ── Search ────────────────────────────────────────────────────────────────────
+router.get("/searchSuggestions", getSearchSuggestions);
+router.get("/searchCourse", searchCourse);
+router.get("/instructorDetails/:instructorId", instructorDetails);
+
 // Content-similar courses – shown on the course detail page
 router.get("/:courseId/similar", getSimilarCourses);
 

server/services/searchIndex.js

@@ -0,0 +1,77 @@
+const Course = require("../models/Course");
+const Trie = require("../utils/trie");
+
+const trie = new Trie();
+let isReady = false;
+
+function indexCourse(course) {
+  const instructor = course.instructor;
+  const instructorName = instructor
+    ? [instructor.firstName, instructor.lastName].filter(Boolean).join(" ")
+    : "";
+
+  trie.insert(course.courseName, {
+    type: "course",
+    id: course._id.toString(),
+    courseId: course._id.toString(),
+    thumbnail: course.thumbnail,
+    instructorName,
+  });
+
+  if (instructor && instructor._id) {
+    trie.insert(instructorName, {
+      type: "instructor",
+      id: instructor._id.toString(),
+      instructorId: instructor._id.toString(),
+      image: instructor.image,
+    });
+  }
+
+  if (Array.isArray(course.tag)) {
+    for (const tag of course.tag) {
+      trie.insert(tag, {
+        type: "tag",
+        id: tag.toLowerCase(),
+        courseId: course._id.toString(),
+      });
+    }
+  }
+
+  if (course.category?.name) {
+    trie.insert(course.category.name, {
+      type: "category",
+      id: course.category._id.toString(),
+      courseId: course._id.toString(),
+    });
+  }
+}
+
+async function rebuild() {
+  trie.clear();
+
+  const courses = await Course.find({ status: "Published" })
+    .populate("instructor", "firstName lastName image")
+    .populate("category", "name")
+    .lean();
+
+  for (const course of courses) {
+    indexCourse(course);
+  }
+
+  isReady = true;
+  return courses.length;
+}
+
+function getSuggestions(prefix, limit = 8) {
+  return trie.search(prefix, limit);
+}
+
+function ready() {
+  return isReady;
+}
+
+module.exports = {
+  rebuild,
+  getSuggestions,
+  ready,
+};

server/utils/trie.js

@@ -0,0 +1,79 @@
+class TrieNode {
+  constructor() {
+    this.children = new Map();
+    this.entries = [];
+  }
+}
+
+class Trie {
+  constructor() {
+    this.root = new TrieNode();
+  }
+
+  _normalize(text) {
+    return text.trim().toLowerCase();
+  }
+
+  insert(text, metadata) {
+    const normalized = this._normalize(text);
+    if (!normalized) return;
+
+    let node = this.root;
+    for (const char of normalized) {
+      if (!node.children.has(char)) {
+        node.children.set(char, new TrieNode());
+      }
+      node = node.children.get(char);
+    }
+
+    const key = `${metadata.type}:${metadata.id}`;
+    const exists = node.entries.some(
+      (entry) => `${entry.type}:${entry.id}` === key
+    );
+    if (!exists) {
+      node.entries.push({ ...metadata, label: text.trim() });
+    }
+  }
+
+  search(prefix, limit = 8) {
+    const normalized = this._normalize(prefix);
+    if (!normalized) return [];
+
+    let node = this.root;
+    for (const char of normalized) {
+      if (!node.children.has(char)) {
+        return [];
+      }
+      node = node.children.get(char);
+    }
+
+    const results = [];
+    const seen = new Set();
+    this._collectSuggestions(node, results, seen, limit);
+    return results;
+  }
+
+  _collectSuggestions(node, results, seen, limit) {
+    if (results.length >= limit) return;
+
+    for (const entry of node.entries) {
+      const key = `${entry.type}:${entry.id}`;
+      if (!seen.has(key)) {
+        seen.add(key);
+        results.push(entry);
+        if (results.length >= limit) return;
+      }
+    }
+
+    for (const child of node.children.values()) {
+      this._collectSuggestions(child, results, seen, limit);
+      if (results.length >= limit) return;
+    }
+  }
+
+  clear() {
+    this.root = new TrieNode();
+  }
+}
+
+module.exports = Trie;

src/App.js

@@ -45,7 +45,7 @@ function App() {
         <Route path="/" element={<Home />} />
         <Route path="about" element={<About />} />
         <Route path="contact" element={<Contact />} />
-        <Route path="search" element={<Search />} />
+        <Route path="search/:query" element={<Search />} />
         <Route path="error" element={<Error />} />
         <Route path="/catalog/:catalogName" element={<Catalog />} />
         <Route path="/courses/:courseId" element={<CourseDetails />} />