@86d-app/search 0.0.3

package/src/service-impl.ts

@@ -0,0 +1,395 @@
+import type { ModuleDataService } from "@86d-app/core";
+import type {
+	SearchController,
+	SearchIndexItem,
+	SearchQuery,
+	SearchResult,
+	SearchSynonym,
+} from "./service";
+
+function normalize(text: string): string {
+	return text.toLowerCase().trim().replace(/\s+/g, " ");
+}
+
+function tokenize(text: string): string[] {
+	return normalize(text)
+		.split(/[\s\-_/,.]+/)
+		.filter((t) => t.length > 0);
+}
+
+function scoreMatch(
+	item: SearchIndexItem,
+	queryTokens: string[],
+	expandedTerms: Set<string>,
+): number {
+	let score = 0;
+	const titleLower = normalize(item.title);
+	const bodyLower = item.body ? normalize(item.body) : "";
+	const tagLower = item.tags.map((t) => normalize(t));
+
+	for (const token of queryTokens) {
+		const allTerms = [token, ...expandedTerms];
+		for (const term of allTerms) {
+			// Exact title match is highest value
+			if (titleLower === term) {
+				score += 100;
+			} else if (titleLower.startsWith(term)) {
+				score += 50;
+			} else if (titleLower.includes(term)) {
+				score += 25;
+			}
+
+			// Body match
+			if (bodyLower.includes(term)) {
+				score += 10;
+			}
+
+			// Tag match
+			for (const tag of tagLower) {
+				if (tag === term) {
+					score += 30;
+				} else if (tag.includes(term)) {
+					score += 15;
+				}
+			}
+		}
+	}
+
+	return score;
+}
+
+export function createSearchController(
+	data: ModuleDataService,
+): SearchController {
+	return {
+		async indexItem(params) {
+			// Check if already indexed — update if so
+			const existing = await data.findMany("searchIndex", {
+				where: {
+					entityType: params.entityType,
+					entityId: params.entityId,
+				},
+				take: 1,
+			});
+			const existingItems = existing as unknown as SearchIndexItem[];
+
+			const id =
+				existingItems.length > 0 ? existingItems[0].id : crypto.randomUUID();
+			const item: SearchIndexItem = {
+				id,
+				entityType: params.entityType,
+				entityId: params.entityId,
+				title: params.title,
+				body: params.body,
+				tags: params.tags ?? [],
+				url: params.url,
+				image: params.image,
+				metadata: params.metadata ?? {},
+				indexedAt: new Date(),
+			};
+			// biome-ignore lint/suspicious/noExplicitAny: ModuleDataService requires any
+			await data.upsert("searchIndex", id, item as Record<string, any>);
+			return item;
+		},
+
+		async removeFromIndex(entityType, entityId) {
+			const items = await data.findMany("searchIndex", {
+				where: { entityType, entityId },
+			});
+			const found = items as unknown as SearchIndexItem[];
+			if (found.length === 0) return false;
+			for (const item of found) {
+				await data.delete("searchIndex", item.id);
+			}
+			return true;
+		},
+
+		async search(query, options) {
+			const limit = options?.limit ?? 20;
+			const skip = options?.skip ?? 0;
+			const queryTokens = tokenize(query);
+
+			if (queryTokens.length === 0) {
+				return { results: [], total: 0 };
+			}
+
+			// Load synonyms for query expansion
+			const allSynonyms = (await data.findMany(
+				"searchSynonym",
+				{},
+			)) as unknown as SearchSynonym[];
+			const expandedTerms = new Set<string>();
+			for (const syn of allSynonyms) {
+				const synTermNorm = normalize(syn.term);
+				for (const token of queryTokens) {
+					if (token === synTermNorm) {
+						for (const s of syn.synonyms) {
+							expandedTerms.add(normalize(s));
+						}
+					}
+					// Also reverse: if a query token matches a synonym, expand to the term
+					for (const s of syn.synonyms) {
+						if (normalize(s) === token) {
+							expandedTerms.add(synTermNorm);
+						}
+					}
+				}
+			}
+
+			// biome-ignore lint/suspicious/noExplicitAny: JSONB where filter
+			const where: Record<string, any> = {};
+			if (options?.entityType) {
+				where.entityType = options.entityType;
+			}
+
+			const allItems = (await data.findMany("searchIndex", {
+				...(Object.keys(where).length > 0 ? { where } : {}),
+			})) as unknown as SearchIndexItem[];
+
+			// Score and rank
+			const scored: SearchResult[] = [];
+			for (const item of allItems) {
+				const score = scoreMatch(item, queryTokens, expandedTerms);
+				if (score > 0) {
+					scored.push({ item, score });
+				}
+			}
+
+			scored.sort((a, b) => b.score - a.score);
+			const total = scored.length;
+			const results = scored.slice(skip, skip + limit);
+
+			return { results, total };
+		},
+
+		async suggest(prefix, limit = 10) {
+			const prefixNorm = normalize(prefix);
+			if (prefixNorm.length === 0) return [];
+
+			// Combine popular terms + index titles
+			const allQueries = (await data.findMany(
+				"searchQuery",
+				{},
+			)) as unknown as SearchQuery[];
+
+			// Count query frequency
+			const termCounts = new Map<string, number>();
+			for (const q of allQueries) {
+				if (q.resultCount > 0 && q.normalizedTerm.startsWith(prefixNorm)) {
+					termCounts.set(q.term, (termCounts.get(q.term) ?? 0) + 1);
+				}
+			}
+
+			// Also match index titles
+			const allItems = (await data.findMany(
+				"searchIndex",
+				{},
+			)) as unknown as SearchIndexItem[];
+			const titleSuggestions: string[] = [];
+			for (const item of allItems) {
+				if (normalize(item.title).includes(prefixNorm)) {
+					titleSuggestions.push(item.title);
+				}
+			}
+
+			// Merge: popular terms first, then title suggestions
+			const popularTerms = Array.from(termCounts.entries())
+				.sort((a, b) => b[1] - a[1])
+				.map(([term]) => term);
+
+			const seen = new Set<string>();
+			const suggestions: string[] = [];
+			for (const term of popularTerms) {
+				const norm = normalize(term);
+				if (!seen.has(norm)) {
+					seen.add(norm);
+					suggestions.push(term);
+				}
+			}
+			for (const title of titleSuggestions) {
+				const norm = normalize(title);
+				if (!seen.has(norm)) {
+					seen.add(norm);
+					suggestions.push(title);
+				}
+			}
+
+			return suggestions.slice(0, limit);
+		},
+
+		async recordQuery(term, resultCount, sessionId) {
+			const id = crypto.randomUUID();
+			const query: SearchQuery = {
+				id,
+				term,
+				normalizedTerm: normalize(term),
+				resultCount,
+				sessionId,
+				searchedAt: new Date(),
+			};
+			// biome-ignore lint/suspicious/noExplicitAny: ModuleDataService requires any
+			await data.upsert("searchQuery", id, query as Record<string, any>);
+			return query;
+		},
+
+		async getRecentQueries(sessionId, limit = 10) {
+			const all = (await data.findMany("searchQuery", {
+				where: { sessionId },
+			})) as unknown as SearchQuery[];
+
+			// Sort by date desc, deduplicate by normalized term
+			all.sort(
+				(a, b) =>
+					new Date(b.searchedAt).getTime() - new Date(a.searchedAt).getTime(),
+			);
+
+			const seen = new Set<string>();
+			const results: SearchQuery[] = [];
+			for (const q of all) {
+				if (!seen.has(q.normalizedTerm)) {
+					seen.add(q.normalizedTerm);
+					results.push(q);
+				}
+				if (results.length >= limit) break;
+			}
+
+			return results;
+		},
+
+		async getPopularTerms(limit = 20) {
+			const all = (await data.findMany(
+				"searchQuery",
+				{},
+			)) as unknown as SearchQuery[];
+
+			const termStats = new Map<
+				string,
+				{ term: string; count: number; totalResults: number }
+			>();
+			for (const q of all) {
+				const existing = termStats.get(q.normalizedTerm);
+				if (existing) {
+					existing.count += 1;
+					existing.totalResults += q.resultCount;
+				} else {
+					termStats.set(q.normalizedTerm, {
+						term: q.term,
+						count: 1,
+						totalResults: q.resultCount,
+					});
+				}
+			}
+
+			return Array.from(termStats.values())
+				.map((s) => ({
+					term: s.term,
+					count: s.count,
+					avgResultCount: Math.round(s.totalResults / s.count),
+				}))
+				.sort((a, b) => b.count - a.count)
+				.slice(0, limit);
+		},
+
+		async getZeroResultQueries(limit = 20) {
+			const all = (await data.findMany(
+				"searchQuery",
+				{},
+			)) as unknown as SearchQuery[];
+
+			const termStats = new Map<string, { term: string; count: number }>();
+			for (const q of all) {
+				if (q.resultCount === 0) {
+					const existing = termStats.get(q.normalizedTerm);
+					if (existing) {
+						existing.count += 1;
+					} else {
+						termStats.set(q.normalizedTerm, {
+							term: q.term,
+							count: 1,
+						});
+					}
+				}
+			}
+
+			return Array.from(termStats.values())
+				.map((s) => ({
+					term: s.term,
+					count: s.count,
+					avgResultCount: 0,
+				}))
+				.sort((a, b) => b.count - a.count)
+				.slice(0, limit);
+		},
+
+		async getAnalytics() {
+			const all = (await data.findMany(
+				"searchQuery",
+				{},
+			)) as unknown as SearchQuery[];
+
+			if (all.length === 0) {
+				return {
+					totalQueries: 0,
+					uniqueTerms: 0,
+					avgResultCount: 0,
+					zeroResultCount: 0,
+					zeroResultRate: 0,
+				};
+			}
+
+			const uniqueTerms = new Set(all.map((q) => q.normalizedTerm));
+			const totalResults = all.reduce((sum, q) => sum + q.resultCount, 0);
+			const zeroResultCount = all.filter((q) => q.resultCount === 0).length;
+
+			return {
+				totalQueries: all.length,
+				uniqueTerms: uniqueTerms.size,
+				avgResultCount: Math.round(totalResults / all.length),
+				zeroResultCount,
+				zeroResultRate: Math.round((zeroResultCount / all.length) * 100),
+			};
+		},
+
+		async addSynonym(term, synonyms) {
+			// Check if synonym for this term already exists
+			const existing = await data.findMany("searchSynonym", {
+				where: { term: normalize(term) },
+				take: 1,
+			});
+			const existingItems = existing as unknown as SearchSynonym[];
+
+			const id =
+				existingItems.length > 0 ? existingItems[0].id : crypto.randomUUID();
+			const synonym: SearchSynonym = {
+				id,
+				term: normalize(term),
+				synonyms: synonyms.map((s) => s.trim()),
+				createdAt:
+					existingItems.length > 0 ? existingItems[0].createdAt : new Date(),
+			};
+			// biome-ignore lint/suspicious/noExplicitAny: ModuleDataService requires any
+			await data.upsert("searchSynonym", id, synonym as Record<string, any>);
+			return synonym;
+		},
+
+		async removeSynonym(id) {
+			const existing = await data.get("searchSynonym", id);
+			if (!existing) return false;
+			await data.delete("searchSynonym", id);
+			return true;
+		},
+
+		async listSynonyms() {
+			const all = (await data.findMany(
+				"searchSynonym",
+				{},
+			)) as unknown as SearchSynonym[];
+			return all;
+		},
+
+		async getIndexCount() {
+			const all = await data.findMany("searchIndex", {});
+			return all.length;
+		},
+	};
+}

package/src/service.ts

@@ -0,0 +1,97 @@
+import type { ModuleController } from "@86d-app/core";
+
+export interface SearchIndexItem {
+	id: string;
+	entityType: string;
+	entityId: string;
+	title: string;
+	body?: string | undefined;
+	tags: string[];
+	url: string;
+	image?: string | undefined;
+	metadata: Record<string, unknown>;
+	indexedAt: Date;
+}
+
+export interface SearchQuery {
+	id: string;
+	term: string;
+	normalizedTerm: string;
+	resultCount: number;
+	sessionId?: string | undefined;
+	searchedAt: Date;
+}
+
+export interface SearchSynonym {
+	id: string;
+	term: string;
+	synonyms: string[];
+	createdAt: Date;
+}
+
+export interface SearchResult {
+	item: SearchIndexItem;
+	score: number;
+}
+
+export interface SearchAnalyticsSummary {
+	totalQueries: number;
+	uniqueTerms: number;
+	avgResultCount: number;
+	zeroResultCount: number;
+	zeroResultRate: number;
+}
+
+export interface PopularTerm {
+	term: string;
+	count: number;
+	avgResultCount: number;
+}
+
+export interface SearchController extends ModuleController {
+	indexItem(params: {
+		entityType: string;
+		entityId: string;
+		title: string;
+		body?: string | undefined;
+		tags?: string[] | undefined;
+		url: string;
+		image?: string | undefined;
+		metadata?: Record<string, unknown> | undefined;
+	}): Promise<SearchIndexItem>;
+
+	removeFromIndex(entityType: string, entityId: string): Promise<boolean>;
+
+	search(
+		query: string,
+		options?: {
+			entityType?: string | undefined;
+			limit?: number | undefined;
+			skip?: number | undefined;
+		},
+	): Promise<{ results: SearchResult[]; total: number }>;
+
+	suggest(prefix: string, limit?: number): Promise<string[]>;
+
+	recordQuery(
+		term: string,
+		resultCount: number,
+		sessionId?: string | undefined,
+	): Promise<SearchQuery>;
+
+	getRecentQueries(sessionId: string, limit?: number): Promise<SearchQuery[]>;
+
+	getPopularTerms(limit?: number): Promise<PopularTerm[]>;
+
+	getZeroResultQueries(limit?: number): Promise<PopularTerm[]>;
+
+	getAnalytics(): Promise<SearchAnalyticsSummary>;
+
+	addSynonym(term: string, synonyms: string[]): Promise<SearchSynonym>;
+
+	removeSynonym(id: string): Promise<boolean>;
+
+	listSynonyms(): Promise<SearchSynonym[]>;
+
+	getIndexCount(): Promise<number>;
+}

package/src/store/components/_hooks.ts

@@ -0,0 +1,12 @@
+"use client";
+
+import { useModuleClient } from "@86d-app/core/client";
+
+export function useSearchApi() {
+	const client = useModuleClient();
+	return {
+		search: client.module("search").store["/search"],
+		suggest: client.module("search").store["/search/suggest"],
+		recent: client.module("search").store["/search/recent"],
+	};
+}

package/src/store/components/index.tsx

@@ -0,0 +1,12 @@
+"use client";
+
+import type { MDXComponents } from "mdx/types";
+import { SearchBar } from "./search-bar";
+import { SearchPage } from "./search-page";
+import { SearchResults } from "./search-results";
+
+export default {
+	SearchBar,
+	SearchResults,
+	SearchPage,
+} satisfies MDXComponents;

package/src/store/components/search-bar.tsx

@@ -0,0 +1,153 @@
+"use client";
+
+import { useCallback, useEffect, useRef, useState } from "react";
+import { useSearchApi } from "./_hooks";
+
+interface SearchBarProps {
+	placeholder?: string | undefined;
+	onSearch?: ((query: string) => void) | undefined;
+}
+
+export function SearchBar({
+	placeholder = "Search...",
+	onSearch,
+}: SearchBarProps) {
+	const api = useSearchApi();
+	const [query, setQuery] = useState("");
+	const [suggestions, setSuggestions] = useState<string[]>([]);
+	const [showSuggestions, setShowSuggestions] = useState(false);
+	const [selectedIndex, setSelectedIndex] = useState(-1);
+	const inputRef = useRef<HTMLInputElement>(null);
+	const containerRef = useRef<HTMLDivElement>(null);
+
+	const { data: suggestData } =
+		query.trim().length >= 2
+			? (api.suggest.useQuery({ q: query.trim(), limit: "8" }) as {
+					data: { suggestions: string[] } | undefined;
+				})
+			: { data: undefined };
+
+	useEffect(() => {
+		if (suggestData?.suggestions) {
+			setSuggestions(suggestData.suggestions);
+		} else {
+			setSuggestions([]);
+		}
+	}, [suggestData]);
+
+	const handleSubmit = useCallback(
+		(term: string) => {
+			const trimmed = term.trim();
+			if (trimmed.length === 0) return;
+			setShowSuggestions(false);
+			setSelectedIndex(-1);
+			onSearch?.(trimmed);
+		},
+		[onSearch],
+	);
+
+	const handleKeyDown = (e: React.KeyboardEvent<HTMLInputElement>) => {
+		if (e.key === "ArrowDown") {
+			e.preventDefault();
+			setSelectedIndex((i) => Math.min(i + 1, suggestions.length - 1));
+		} else if (e.key === "ArrowUp") {
+			e.preventDefault();
+			setSelectedIndex((i) => Math.max(i - 1, -1));
+		} else if (e.key === "Enter") {
+			e.preventDefault();
+			if (selectedIndex >= 0 && suggestions[selectedIndex]) {
+				setQuery(suggestions[selectedIndex]);
+				handleSubmit(suggestions[selectedIndex]);
+			} else {
+				handleSubmit(query);
+			}
+		} else if (e.key === "Escape") {
+			setShowSuggestions(false);
+			setSelectedIndex(-1);
+		}
+	};
+
+	// Close suggestions on click outside
+	useEffect(() => {
+		const handleClick = (e: MouseEvent) => {
+			if (
+				containerRef.current &&
+				!containerRef.current.contains(e.target as Node)
+			) {
+				setShowSuggestions(false);
+			}
+		};
+		document.addEventListener("mousedown", handleClick);
+		return () => document.removeEventListener("mousedown", handleClick);
+	}, []);
+
+	return (
+		<div ref={containerRef} className="relative w-full">
+			<div className="relative">
+				<svg
+					className="absolute top-1/2 left-3 h-4 w-4 -translate-y-1/2 text-muted-foreground"
+					xmlns="http://www.w3.org/2000/svg"
+					fill="none"
+					viewBox="0 0 24 24"
+					strokeWidth={2}
+					stroke="currentColor"
+					aria-hidden="true"
+				>
+					<title>Search</title>
+					<path
+						strokeLinecap="round"
+						strokeLinejoin="round"
+						d="m21 21-5.197-5.197m0 0A7.5 7.5 0 1 0 5.196 5.196a7.5 7.5 0 0 0 10.607 10.607Z"
+					/>
+				</svg>
+				<input
+					ref={inputRef}
+					type="search"
+					value={query}
+					onChange={(e) => {
+						setQuery(e.target.value);
+						setShowSuggestions(true);
+						setSelectedIndex(-1);
+					}}
+					onFocus={() => setShowSuggestions(true)}
+					onKeyDown={handleKeyDown}
+					placeholder={placeholder}
+					className="w-full rounded-lg border border-border bg-background py-2.5 pr-4 pl-10 text-foreground text-sm placeholder:text-muted-foreground focus:border-primary focus:outline-none focus:ring-1 focus:ring-primary"
+					aria-label="Search"
+					aria-autocomplete="list"
+					aria-expanded={showSuggestions && suggestions.length > 0}
+					role="combobox"
+				/>
+			</div>
+
+			{showSuggestions && suggestions.length > 0 && (
+				<div
+					role="listbox"
+					className="absolute z-50 mt-1 w-full overflow-hidden rounded-lg border border-border bg-background shadow-lg"
+				>
+					{suggestions.map((suggestion, index) => (
+						<div
+							key={suggestion}
+							role="option"
+							tabIndex={-1}
+							aria-selected={index === selectedIndex}
+							className={`cursor-pointer px-4 py-2 text-sm ${
+								index === selectedIndex
+									? "bg-muted text-foreground"
+									: "text-foreground hover:bg-muted/50"
+							}`}
+							onMouseDown={(e) => {
+								e.preventDefault();
+								setQuery(suggestion);
+								handleSubmit(suggestion);
+							}}
+							onMouseEnter={() => setSelectedIndex(index)}
+						>
+							{suggestion}
+						</div>
+					))}
+				</div>
+			)}
+		</div>
+	);
+}

package/src/store/components/search-page.tsx

@@ -0,0 +1,26 @@
+"use client";
+
+import { useCallback, useState } from "react";
+import { SearchBar } from "./search-bar";
+import { SearchResults } from "./search-results";
+
+export function SearchPage({ sessionId }: { sessionId?: string | undefined }) {
+	const [query, setQuery] = useState("");
+
+	const handleSearch = useCallback((term: string) => {
+		setQuery(term);
+	}, []);
+
+	return (
+		<div className="mx-auto max-w-2xl px-4 py-8">
+			<h1 className="mb-6 font-semibold text-2xl text-foreground">Search</h1>
+			<SearchBar
+				placeholder="Search products, articles..."
+				onSearch={handleSearch}
+			/>
+			<div className="mt-6">
+				<SearchResults query={query} sessionId={sessionId} />
+			</div>
+		</div>
+	);
+}