Implemented levenshtein distance algorithm and changed unit tests to match

Author: aspies06

api/main_endpoints/routes/ShortcutSearch.js

@@ -27,78 +27,48 @@ router.post('/', async function(req, res) {
     return res.status(OK).send({ items: [] });
   }
 
-  const query = req.body.query.replace(/[*\s]/g, '');
+  // function for calculating how similar strings are to each other via levenshtein distance
+  function levenshteinDistance(a, b) {
+    const m = a.length;
+    const n = b.length;
 
-  // Create a fuzzy regex pattern to match characters in order, e.g., "pone" -> /p.*o.*n.*e/i
-  const fuzzyPattern = query.split('').join('.*');
-  const pattern = new RegExp(fuzzyPattern, 'i');
+    if (m === 0) return n;
+    if (n === 0) return m;
 
-  const maybeOr = {
-    $or: [
-      {
-        $expr: {
-          $regexMatch: {
-            input: { $concat: ['$firstName', '$lastName'] },
-            regex: pattern,
-          }
-        }
-      },
-      { email: { $regex: new RegExp(query, 'i')} }
-    ]
-  };
+    const dp = Array.from({ length: m + 1 }, () => Array(n + 1));
+    for (let i = 0; i <= m; i++) dp[i][0] = i;
+    for (let j = 0; j <= n; j++) dp[0][j] = j;
 
-  /**
-   * Function to calculate scores based on token matches for sorting
-   * @param {string} str - The string to score against
-   * @param {Array} tokens - The tokens to match against the string
-   * @return {number} - The score based on matches
-   */
-  const tokenScores = (str, tokens) => {
-    return tokens.reduce((score, token) => {
-      if (str.startsWith(token)) return score; // highest score for exact match
-      if (str.includes(token)) return score + 1; // lower score for partial match
-      return score + 2; // lowest score for no match
-    }, 0);
-  };
-
-  /**
-   * Sorts the user items based on the query match
-   * @param {string} query input string to match against
-   * @returns {function} - A comparison function for sorting
-   */
-  const sortByMatch = (query) => {
-    const input = query.toLowerCase().split(/[\s@._-]+/).filter(Boolean);
-
-    return (a, b) => {
-      const aName = (a.firstName + ' ' + a.lastName).toLowerCase();
-      const bName = (b.firstName + ' ' + b.lastName).toLowerCase();
-      const aEmail = a.email.toLowerCase();
-      const bEmail = b.email.toLowerCase();
-
-      // First Priority: sort by name match
-      const nameScoreA = tokenScores(aName, input);
-      const nameScoreB = tokenScores(bName, input);
-      if (nameScoreA !== nameScoreB) {
-        return nameScoreA - nameScoreB;
-      }
-
-      // Second Priority: sort by email match
-      const emailScoreA = tokenScores(aEmail, input);
-      const emailScoreB = tokenScores(bEmail, input);
-      if (emailScoreA !== emailScoreB) {
-        return emailScoreA - emailScoreB;
+    for (let i = 1; i <= m; i++) {
+      for (let j = 1; j <= n; j++) {
+        const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+        dp[i][j] = Math.min(
+          dp[i - 1][j] + 1,
+          dp[i][j - 1] + 1,
+          dp[i - 1][j - 1] + cost
+        );
       }
+    }
+    return dp[m][n];
+  }
 
-      // Tie-breaker: alphabetical email sort
-      return a.email.localeCompare(b.email);
-    };
-  };
+  // Find top 5 matching users and sort results based on best match of name or email
+  User.find({}, { password: 0 })
+    .then(users => {
+      const matchingUsers = users.map(user => {
+        const firstNameScore = levenshteinDistance(req.body.query, user.firstName);
+        const lastNameScore = levenshteinDistance(req.body.query, user.lastName);
+        const emailScore = levenshteinDistance(req.body.query, user.email);
+        return {
+          user,
+          score: Math.min(firstNameScore, lastNameScore, emailScore)
+        };
+      });
 
-  // Find user and sort results based on best match of full name or email
-  User.find(maybeOr, { password: 0 })
-    .limit(5)
-    .then(items => {
-      items.sort(sortByMatch(req.body.query));
+      const items = matchingUsers
+        .sort((a, b) => a.score - b.score)
+        .slice(0, 5)
+        .map(item => item.user);
       res.status(OK).send({ items });
     })
     .catch((error) => {

test/api/ShortcutSearch.js

@@ -205,31 +205,31 @@ describe('ShortcutSearch', () => {
         expect(result.body.items).that.is.an('array').to.have.lengthOf(5);
       });
 
-      it('Should return no records when query = \'Pika\'', async () => {
+      it('Should return FIVE records when query = \'Pika\'', async () => {
         const result = await test.sendPostRequestWithToken(token, url, { query: 'Pika' });
         expect(result).to.have.status(OK);
-        expect(result.body.items).that.is.an('array').that.is.empty;
+        expect(result.body.items).that.is.an('array').to.have.lengthOf(5);
       });
 
       beforeEach(() => {
         setTokenStatus(true, { accessLevel: MEMBERSHIP_STATE.ADMIN });
       });
 
-      it('Should return THREE records when query = \'coOl\'', async () => {
+      it('Should return FIVE records when query = \'coOl\'', async () => {
         const result = await test.sendPostRequestWithToken(token, url, queryUser);
         expect(result).to.have.status(OK);
-        expect(result.body.items).that.is.an('array').to.have.lengthOf(3);
+        expect(result.body.items).that.is.an('array').to.have.lengthOf(5);
       });
 
       it('Should show results sorted by best match of name and email', async () => {
         const result = await test.sendPostRequestWithToken(token, url, fiveMatchUsers);
         expect(result).to.have.status(OK);
         expect(result.body.items.map(u => u.email)).to.eql([
           '[email protected]',
-          'test0@test.com',
-          'test00@test.com',
-          'test2@test.com',
-          'test3@test.com'
+          'test3@test.com',
+          'test5@test.com',
+          'test7@test.com',
+          'test0@test.com'
         ]);
       });
     });