refac: test removing lodash && remove old as hell difflib library

apps/queue/package.json

@@ -24,6 +24,7 @@
     "@next/common": "workspace:^",
     "bullmq": "^4.12.5",
     "close-with-grace": "^1.2.0",
+    "diff": "^5.1.0",
     "dotenv": "^16.3.1",
     "lodash-es": "^4.17.21",
     "ofetch": "^1.1.1",
@@ -33,6 +34,7 @@
     "@next/constants": "workspace:*",
     "@next/models": "workspace:*",
     "@next/tsconfig": "workspace:^",
+    "@types/diff": "^5.0.7",
     "@types/lodash-es": "^4.17.10",
     "tsup": "^7.2.0"
   }

apps/queue/src/helpers/identifier.ts

@@ -1,29 +1,34 @@
 import { createHash } from 'node:crypto';
 import { logger } from '@next/common';
-import { camelCase, chain } from 'lodash-es';
+import { camelCase } from 'lodash-es';
+import type { Disciplina } from '@/types/models.js';
 
 /**
  * Generates a unique identifier for a given disciplina
  * */
 export function generateIdentifier(
-  disciplina: Record<string, unknown>,
-  keys: string[],
+  disciplina: Record<string, Disciplina>,
+  keys: string[] = ['disciplina', 'turno', 'campus', 'turma'],
   silent = true,
 ) {
-  keys = keys || ['disciplina', 'turno', 'campus', 'turma'];
-
   //TODO: Find a way of doing this without lodash
-  const disc = chain(disciplina)
-    .pick(keys)
-    .mapValues(String)
-    .mapValues((value: string) => {
-      camelCase(value);
-    })
-    .toPairs()
-    .sortBy(0)
-    .fromPairs()
-    .values()
-    .value()
+  // const disc = chain(disciplina)
+  //   .pick(keys)
+  //   .mapValues(String)
+  //   .mapValues((value: string) => {
+  //     camelCase(value);
+  //   })
+  //   .toPairs()
+  //   .sortBy(0)
+  //   .fromPairs()
+  //   .values()
+  //   .value()
+  //   .join('');
+
+  // TODO2: See if it behaves the same
+  const disc = keys
+    .map((key) => String(disciplina[key]))
+    .map((value) => camelCase(value)) // Use camelCase
     .join('');
 
   if (!silent) {

apps/queue/src/helpers/resolveProfessors.ts

@@ -1,6 +1,6 @@
-import { SequenceMatcher, getCloseMatches } from 'difflib';
+import { diffChars } from 'diff';
 import { camelCase, startCase } from 'lodash-es';
-import type { Teacher } from '@next/models';
+import type { Teacher } from '@/types/models.js';
 
 export function resolveProfessors(
   name: string,
@@ -12,32 +12,40 @@ export function resolveProfessors(
   }
 
   const normalizedName = startCase(camelCase(name));
+  const isNameInvalid =
+    !normalizedName || ['N D', 'Falso'].includes(normalizedName);
 
-  if (
-    !normalizedName ||
-    normalizedName === 'N D' ||
-    normalizedName === 'Falso'
-  ) {
+  if (isNameInvalid) {
     return null;
   }
-
-  const foundTeacher =
-    teachers.find((t) => t.name === normalizedName) ||
-    teachers.find((t) => (t.alias || []).includes(normalizedName));
+  const isTeacherPresent = (t: Teacher) =>
+    t.name === normalizedName ?? (t.alias || []).includes(normalizedName);
+  const foundTeacher = teachers.find((teacher) => isTeacherPresent(teacher));
 
   if (foundTeacher) {
     return foundTeacher;
   }
 
-  const bestMatch = getCloseMatches(
-    normalizedName,
-    teachers.map((t) => t.name),
-  )[0];
+  let bestMatch: string;
+  let bestMatchScore = 0;
+
+  for (const teacher of teachers) {
+    const diff = diffChars(normalizedName, teacher.name);
+    const score = diff.reduce(
+      (acc, part) => (part.added ? acc : acc + part.count!),
+      0,
+    );
 
-  const sequenceMatcher = new SequenceMatcher(null, bestMatch, normalizedName);
+    if (score > bestMatchScore) {
+      bestMatch = teacher.name;
+      bestMatchScore = score;
+    }
+  }
 
-  if (sequenceMatcher.ratio() > 0.8)
+  const similarityThreshold = 0.8;
+  if (bestMatchScore > similarityThreshold) {
     return teachers.find((t) => t.name === bestMatch);
+  }
 
   return { error: `Missing Teacher: ${normalizedName}` };
 }

apps/queue/src/types/models.ts

@@ -28,3 +28,30 @@ export type HistoryDiscipline = {
   disciplina: string;
   identifier: string;
 };
+
+export type Disciplina = {
+  identifier: string;
+  obrigatorias: number[];
+  alunos_matriculados: number[];
+  before_kick: number[];
+  after_kick: number[];
+  year?: number;
+  quad?: number;
+  turno?: string;
+  disciplina?: string;
+  season?: string;
+  teoria?: ObjectId;
+  pratica?: ObjectId;
+  campus?: string;
+  turma?: string;
+  subject?: ObjectId;
+  codigo?: string;
+  disciplina_id?: number;
+  vagas?: number;
+  ideal_quad?: boolean;
+};
+
+export type Teacher = {
+  alias: string[];
+  name: string;
+};