fix: fuzzy search the millionth time

Author: castdrian

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@castdrian/kdapi",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "type": "module",
   "description": "kpop idol and group profiles dataset generator",
   "main": "dist/index.js",

src/index.ts

@@ -13,18 +13,19 @@ const dataset: DataSet = {
 
 const groupSearchOptions: IFuseOptions<Group> = {
 	keys: [
-		{ name: "groupInfo.names.stage", weight: 2.5 },
-		{ name: "groupInfo.names.korean", weight: 2 },
-		{ name: "groupInfo.names.japanese", weight: 1.5 },
-		{ name: "groupInfo.names.chinese", weight: 1.5 },
+		{ name: "groupInfo.names.stage", weight: 10 },
+		{ name: "groupInfo.names.korean", weight: 3 },
+		{ name: "groupInfo.names.japanese", weight: 2 },
+		{ name: "groupInfo.names.chinese", weight: 2 },
 		{ name: "groupInfo.fandomName", weight: 0.5 },
 		{ name: "company.current", weight: 0.3 },
-		{ name: "memberHistory.currentMembers.name", weight: 0.3 },
+		{ name: "memberHistory.currentMembers.name", weight: 0.2 },
 	],
 	includeScore: true,
-	threshold: 0.4,
+	threshold: 0.3,
 	ignoreLocation: true,
 	minMatchCharLength: 2,
+	shouldSort: true,
 };
 
 const idolSearchOptions: IFuseOptions<Idol> = {
@@ -35,10 +36,7 @@ const idolSearchOptions: IFuseOptions<Idol> = {
 		{ name: "names.korean", weight: 2 },
 		{ name: "names.japanese", weight: 1.5 },
 		{ name: "names.chinese", weight: 1.5 },
-		{
-			name: "groups.name",
-			weight: 1,
-		},
+		{ name: "groups.name", weight: 1 },
 	],
 	includeScore: true,
 	threshold: 0.3,
@@ -66,7 +64,11 @@ export function search(
 	} = {},
 ) {
 	const { type = "all", limit = 10, threshold } = options;
-	const results: { item: Idol | Group; type: "idol" | "group" }[] = [];
+	let results: {
+		item: Idol | Group;
+		type: "idol" | "group";
+		score?: number;
+	}[] = [];
 
 	// Split query into words for better matching
 	const words = query.toLowerCase().trim().split(/\s+/);
@@ -93,70 +95,94 @@ export function search(
 			: idolSearcher;
 
 	if (hasMultipleWords) {
+		// Split search into individual words
 		const [firstWord, ...restWords] = words;
-		if (!firstWord) return [];
-		const restWordsStr = restWords.join(" ");
-
-		// Search for idols matching the first word
-		const potentialIdols = idolSearcherInstance.search(firstWord);
-
-		// Add matches where idol belongs to the specified group
-		for (const idolResult of potentialIdols) {
-			const idol = idolResult.item;
-			if (idol.groups?.some((g) => g.name.toLowerCase() === restWordsStr)) {
-				results.push({
-					item: idol,
-					type: "idol",
-				});
-			}
-		}
 
-		// Try reverse order (group first, then idol name)
-		const reversePotentialIdols = idolSearcherInstance.search(restWordsStr);
-		for (const idolResult of reversePotentialIdols) {
-			const idol = idolResult.item;
-			if (idol.groups?.some((g) => g.name.toLowerCase() === firstWord)) {
-				results.push({
-					item: idol,
-					type: "idol",
-				});
-			}
-		}
+		// Search for the first word
+		const firstWordResults = firstWord ? search(firstWord, { limit: 50 }) : [];
+
+		// Filter results that match all words
+		results = firstWordResults.filter((result) => {
+			const textToSearch =
+				result.type === "group"
+					? [
+							(result.item as Group).groupInfo.names.stage,
+							...((result.item as Group).memberHistory?.currentMembers?.map(
+								(m) => m.name,
+							) || []),
+						]
+					: [
+							(result.item as Idol).names.stage,
+							(result.item as Idol).names.full,
+							...((result.item as Idol).groups?.map((g) => g.name) || []),
+						];
+
+			return restWords.every((word) =>
+				textToSearch.some((text) => text?.toLowerCase().includes(word)),
+			);
+		});
+	} else {
+		const normalizedQuery = query.toLowerCase().trim();
+
+		// First check for exact group matches if we're not specifically searching for idols
+		if (type !== "idol") {
+			const exactGroupMatches = [
+				...dataset.girlGroups,
+				...dataset.boyGroups,
+				...dataset.coedGroups,
+			]
+				.filter(
+					(group) =>
+						group.groupInfo.names.stage?.toLowerCase() === normalizedQuery,
+				)
+				.map((group) => ({
+					item: group,
+					type: "group" as const,
+					score: 0, // Give exact matches the highest priority
+				}));
+
+			if (exactGroupMatches.length > 0) {
+				results.push(...exactGroupMatches);
 
-		// If no exact matches found, fall back to fuzzy search
-		if (results.length === 0) {
-			for (const idolResult of potentialIdols) {
-				const idol = idolResult.item;
-				if (
-					idol.groups?.some((g) => g.name.toLowerCase().includes(restWordsStr))
-				) {
-					results.push({
-						item: idol,
-						type: "idol",
-					});
+				// If we only want groups, return here
+				if (type === "group") {
+					return exactGroupMatches.slice(0, limit);
 				}
 			}
 		}
-	} else {
+
+		// If no exact matches or we want all results, proceed with fuzzy search
+		if (type === "all" || type === "group") {
+			const groupResults = groupSearcherInstance.search(query);
+			results.push(
+				...groupResults
+					.filter(
+						(result) =>
+							// Exclude exact matches we already added
+							result.item.groupInfo.names.stage?.toLowerCase() !==
+							normalizedQuery,
+					)
+					.map((result) => ({
+						item: result.item,
+						type: "group" as const,
+						score: result.score || 1,
+					})),
+			);
+		}
+
 		if (type === "all" || type === "idol") {
 			const idolResults = idolSearcherInstance.search(query);
 			results.push(
 				...idolResults.map((result) => ({
 					item: result.item,
 					type: "idol" as const,
+					score: result.score || 1,
 				})),
 			);
 		}
 
-		if (type === "all" || type === "group") {
-			const groupResults = groupSearcherInstance.search(query);
-			results.push(
-				...groupResults.map((result) => ({
-					item: result.item,
-					type: "group" as const,
-				})),
-			);
-		}
+		// Sort results by score (lower is better)
+		results = results.sort((a, b) => (a.score || 1) - (b.score || 1));
 	}
 
 	// Remove duplicates
@@ -168,21 +194,4 @@ export function search(
 	return uniqueResults.slice(0, limit);
 }
 
-export type { Idol, Group };
-export function getItemById(
-	id: string,
-): { item: Idol | Group; type: "idol" | "group" } | null {
-	const idol = [...dataset.femaleIdols, ...dataset.maleIdols].find(
-		(i) => i.id === id,
-	);
-	if (idol) return { item: idol, type: "idol" };
-
-	const group = [
-		...dataset.girlGroups,
-		...dataset.boyGroups,
-		...dataset.coedGroups,
-	].find((g) => g.id === id);
-	if (group) return { item: group, type: "group" };
-
-	return null;
-}
+export type { Idol, Group, DataSet, GroupsData, IdolsData };

test/search.test.ts

@@ -20,7 +20,7 @@ describe("Fuzzy Search", () => {
 			results.some(
 				(r) =>
 					r.type === "idol" &&
-					(r.item as Idol).groups?.some((g) =>
+					(r.item as Idol).groups?.some((g: { name: string; }) =>
 						g.name.toLowerCase().includes("stayc"),
 					),
 			),
@@ -33,6 +33,23 @@ describe("Fuzzy Search", () => {
 		expect(results.some((r) => r.type === "group")).toBe(true);
 	});
 
+	test("should return both group and members when searching for group name", () => {
+		const results = search("stayc");
+		const hasGroup = results.some((r) => r.type === "group");
+		const hasMembers = results.some((r) => r.type === "idol");
+		expect(hasGroup).toBe(true);
+		expect(hasMembers).toBe(true);
+	});
+
+	test("should prioritize exact group name matches", () => {
+		const results = search("le sserafim");
+		expect(results.length).toBeGreaterThan(0);
+		expect(results[0]?.type).toBe("group");
+		expect(
+			(results[0]?.item as Group).groupInfo?.names?.stage?.toLowerCase(),
+		).toContain("le sserafim");
+	});
+
 	test("should handle Korean characters", () => {
 		const results = search("스테이씨");
 		expect(results.length).toBeGreaterThan(0);