@86d-app/search 0.0.3

package/src/admin/components/search-analytics.tsx

@@ -0,0 +1,292 @@
+"use client";
+
+import { useModuleClient } from "@86d-app/core/client";
+import { useState } from "react";
+
+interface AnalyticsData {
+	totalQueries: number;
+	uniqueTerms: number;
+	avgResultCount: number;
+	zeroResultCount: number;
+	zeroResultRate: number;
+	indexedItems: number;
+}
+
+interface PopularTerm {
+	term: string;
+	count: number;
+	avgResultCount: number;
+}
+
+interface Synonym {
+	id: string;
+	term: string;
+	synonyms: string[];
+	createdAt: string;
+}
+
+function useSearchAdminApi() {
+	const client = useModuleClient();
+	return {
+		analytics: client.module("search").admin["/admin/search/analytics"],
+		popular: client.module("search").admin["/admin/search/popular"],
+		zeroResults: client.module("search").admin["/admin/search/zero-results"],
+		synonyms: client.module("search").admin["/admin/search/synonyms"],
+		addSynonym: client.module("search").admin["/admin/search/synonyms/add"],
+		removeSynonym:
+			client.module("search").admin["/admin/search/synonyms/:id/delete"],
+	};
+}
+
+function StatCard({ label, value }: { label: string; value: string | number }) {
+	return (
+		<div className="rounded-lg border border-border bg-background p-4">
+			<p className="text-muted-foreground text-xs uppercase tracking-wider">
+				{label}
+			</p>
+			<p className="mt-1 font-semibold text-2xl text-foreground">{value}</p>
+		</div>
+	);
+}
+
+export function SearchAnalytics() {
+	const api = useSearchAdminApi();
+	const [newTerm, setNewTerm] = useState("");
+	const [newSynonyms, setNewSynonyms] = useState("");
+	const [error, setError] = useState("");
+
+	const { data: analyticsData, isLoading: analyticsLoading } =
+		api.analytics.useQuery({}) as {
+			data: { analytics: AnalyticsData } | undefined;
+			isLoading: boolean;
+		};
+
+	const { data: popularData, isLoading: popularLoading } = api.popular.useQuery(
+		{ limit: "15" },
+	) as {
+		data: { terms: PopularTerm[] } | undefined;
+		isLoading: boolean;
+	};
+
+	const { data: zeroData, isLoading: zeroLoading } = api.zeroResults.useQuery({
+		limit: "15",
+	}) as {
+		data: { terms: PopularTerm[] } | undefined;
+		isLoading: boolean;
+	};
+
+	const { data: synonymsData, isLoading: synonymsLoading } =
+		api.synonyms.useQuery({}) as {
+			data: { synonyms: Synonym[] } | undefined;
+			isLoading: boolean;
+		};
+
+	const addMutation = api.addSynonym.useMutation({
+		onSettled: () => {
+			void api.synonyms.invalidate();
+			setNewTerm("");
+			setNewSynonyms("");
+		},
+		onError: () => {
+			setError("Failed to add synonym.");
+		},
+	});
+
+	const removeMutation = api.removeSynonym.useMutation({
+		onSettled: () => {
+			void api.synonyms.invalidate();
+		},
+	});
+
+	const analytics = analyticsData?.analytics;
+	const popularTerms = popularData?.terms ?? [];
+	const zeroResultTerms = zeroData?.terms ?? [];
+	const synonyms = synonymsData?.synonyms ?? [];
+	const loading =
+		analyticsLoading || popularLoading || zeroLoading || synonymsLoading;
+
+	const handleAddSynonym = () => {
+		setError("");
+		const term = newTerm.trim();
+		const syns = newSynonyms
+			.split(",")
+			.map((s) => s.trim())
+			.filter((s) => s.length > 0);
+		if (!term || syns.length === 0) {
+			setError("Enter a term and at least one synonym.");
+			return;
+		}
+		addMutation.mutate({ term, synonyms: syns });
+	};
+
+	if (loading && !analytics) {
+		return (
+			<div className="py-16 text-center">
+				<div className="mx-auto h-8 w-8 animate-spin rounded-full border-2 border-muted border-t-foreground" />
+				<p className="mt-4 text-muted-foreground text-sm">
+					Loading search analytics...
+				</p>
+			</div>
+		);
+	}
+
+	return (
+		<div className="space-y-8">
+			{/* Stats overview */}
+			{analytics && (
+				<div className="grid grid-cols-2 gap-4 md:grid-cols-3 lg:grid-cols-6">
+					<StatCard
+						label="Total Searches"
+						value={analytics.totalQueries.toLocaleString()}
+					/>
+					<StatCard
+						label="Unique Terms"
+						value={analytics.uniqueTerms.toLocaleString()}
+					/>
+					<StatCard label="Avg Results" value={analytics.avgResultCount} />
+					<StatCard
+						label="Zero Results"
+						value={analytics.zeroResultCount.toLocaleString()}
+					/>
+					<StatCard
+						label="Zero Result Rate"
+						value={`${analytics.zeroResultRate}%`}
+					/>
+					<StatCard
+						label="Indexed Items"
+						value={analytics.indexedItems.toLocaleString()}
+					/>
+				</div>
+			)}
+
+			<div className="grid gap-8 md:grid-cols-2">
+				{/* Popular terms */}
+				<div className="rounded-lg border border-border bg-background">
+					<div className="border-border border-b px-5 py-3">
+						<h3 className="font-medium text-foreground text-sm">
+							Popular Search Terms
+						</h3>
+					</div>
+					{popularTerms.length === 0 ? (
+						<p className="px-5 py-6 text-center text-muted-foreground text-sm">
+							No search data yet.
+						</p>
+					) : (
+						<div className="divide-y divide-border">
+							{popularTerms.map((t) => (
+								<div
+									key={t.term}
+									className="flex items-center justify-between px-5 py-2.5"
+								>
+									<span className="text-foreground text-sm">{t.term}</span>
+									<span className="text-muted-foreground text-xs">
+										{t.count} searches &middot; {t.avgResultCount} avg results
+									</span>
+								</div>
+							))}
+						</div>
+					)}
+				</div>
+
+				{/* Zero result queries */}
+				<div className="rounded-lg border border-border bg-background">
+					<div className="border-border border-b px-5 py-3">
+						<h3 className="font-medium text-foreground text-sm">
+							Zero-Result Queries
+						</h3>
+					</div>
+					{zeroResultTerms.length === 0 ? (
+						<p className="px-5 py-6 text-center text-muted-foreground text-sm">
+							No zero-result queries yet.
+						</p>
+					) : (
+						<div className="divide-y divide-border">
+							{zeroResultTerms.map((t) => (
+								<div
+									key={t.term}
+									className="flex items-center justify-between px-5 py-2.5"
+								>
+									<span className="text-foreground text-sm">{t.term}</span>
+									<span className="text-muted-foreground text-xs">
+										{t.count} times
+									</span>
+								</div>
+							))}
+						</div>
+					)}
+				</div>
+			</div>
+
+			{/* Synonyms management */}
+			<div className="rounded-lg border border-border bg-background">
+				<div className="border-border border-b px-5 py-3">
+					<h3 className="font-medium text-foreground text-sm">
+						Search Synonyms
+					</h3>
+				</div>
+				<div className="p-5">
+					<div className="mb-4 flex flex-col gap-2 sm:flex-row">
+						<input
+							type="text"
+							value={newTerm}
+							onChange={(e) => setNewTerm(e.target.value)}
+							placeholder="Term (e.g. tee)"
+							className="rounded-md border border-border bg-background px-3 py-1.5 text-sm focus:border-primary focus:outline-none focus:ring-1 focus:ring-primary"
+						/>
+						<input
+							type="text"
+							value={newSynonyms}
+							onChange={(e) => setNewSynonyms(e.target.value)}
+							placeholder="Synonyms, comma separated (e.g. t-shirt, shirt)"
+							className="flex-1 rounded-md border border-border bg-background px-3 py-1.5 text-sm focus:border-primary focus:outline-none focus:ring-1 focus:ring-primary"
+						/>
+						<button
+							type="button"
+							onClick={handleAddSynonym}
+							disabled={addMutation.isPending}
+							className="rounded-md bg-primary px-4 py-1.5 font-medium text-primary-foreground text-sm hover:bg-primary/90 disabled:opacity-50"
+						>
+							Add
+						</button>
+					</div>
+					{error && <p className="mb-3 text-destructive text-sm">{error}</p>}
+					{synonyms.length === 0 ? (
+						<p className="py-4 text-center text-muted-foreground text-sm">
+							No synonyms configured yet.
+						</p>
+					) : (
+						<div className="divide-y divide-border rounded-md border border-border">
+							{synonyms.map((syn) => (
+								<div
+									key={syn.id}
+									className="flex items-center justify-between px-4 py-2.5"
+								>
+									<div className="text-sm">
+										<span className="font-medium text-foreground">
+											{syn.term}
+										</span>
+										<span className="mx-2 text-muted-foreground">&rarr;</span>
+										<span className="text-muted-foreground">
+											{syn.synonyms.join(", ")}
+										</span>
+									</div>
+									<button
+										type="button"
+										onClick={() =>
+											removeMutation.mutate({
+												params: { id: syn.id },
+											})
+										}
+										className="text-muted-foreground text-xs hover:text-destructive"
+									>
+										Remove
+									</button>
+								</div>
+							))}
+						</div>
+					)}
+				</div>
+			</div>
+		</div>
+	);
+}

package/src/admin/endpoints/analytics.ts

@@ -0,0 +1,15 @@
+import { createAdminEndpoint } from "@86d-app/core";
+import type { SearchController } from "../../service";
+
+export const analyticsEndpoint = createAdminEndpoint(
+	"/admin/search/analytics",
+	{ method: "GET" },
+	async (ctx) => {
+		const controller = ctx.context.controllers.search as SearchController;
+		const [analytics, indexCount] = await Promise.all([
+			controller.getAnalytics(),
+			controller.getIndexCount(),
+		]);
+		return { analytics: { ...analytics, indexedItems: indexCount } };
+	},
+);

package/src/admin/endpoints/index-manage.ts

@@ -0,0 +1,43 @@
+import { createAdminEndpoint, z } from "@86d-app/core";
+import type { SearchController } from "../../service";
+
+export const indexItem = createAdminEndpoint(
+	"/admin/search/index",
+	{
+		method: "POST",
+		body: z.object({
+			entityType: z.string().min(1).max(100),
+			entityId: z.string().min(1).max(200),
+			title: z.string().min(1).max(500),
+			body: z.string().max(10000).optional(),
+			tags: z.array(z.string().max(100)).max(50).optional(),
+			url: z.string().min(1).max(500),
+			image: z.string().max(500).optional(),
+			metadata: z.record(z.string(), z.unknown()).optional(),
+		}),
+	},
+	async (ctx) => {
+		const controller = ctx.context.controllers.search as SearchController;
+		const item = await controller.indexItem(ctx.body);
+		return { item };
+	},
+);
+
+export const removeFromIndex = createAdminEndpoint(
+	"/admin/search/index/remove",
+	{
+		method: "POST",
+		body: z.object({
+			entityType: z.string().min(1).max(100),
+			entityId: z.string().min(1).max(200),
+		}),
+	},
+	async (ctx) => {
+		const controller = ctx.context.controllers.search as SearchController;
+		const removed = await controller.removeFromIndex(
+			ctx.body.entityType,
+			ctx.body.entityId,
+		);
+		return { removed };
+	},
+);

package/src/admin/endpoints/index.ts

@@ -0,0 +1,16 @@
+import { analyticsEndpoint } from "./analytics";
+import { indexItem, removeFromIndex } from "./index-manage";
+import { popularEndpoint } from "./popular";
+import { addSynonym, listSynonyms, removeSynonym } from "./synonyms";
+import { zeroResultsEndpoint } from "./zero-results";
+
+export const adminEndpoints = {
+	"/admin/search/analytics": analyticsEndpoint,
+	"/admin/search/popular": popularEndpoint,
+	"/admin/search/zero-results": zeroResultsEndpoint,
+	"/admin/search/synonyms": listSynonyms,
+	"/admin/search/synonyms/add": addSynonym,
+	"/admin/search/synonyms/:id/delete": removeSynonym,
+	"/admin/search/index": indexItem,
+	"/admin/search/index/remove": removeFromIndex,
+};

package/src/admin/endpoints/popular.ts

@@ -0,0 +1,17 @@
+import { createAdminEndpoint, z } from "@86d-app/core";
+import type { SearchController } from "../../service";
+
+export const popularEndpoint = createAdminEndpoint(
+	"/admin/search/popular",
+	{
+		method: "GET",
+		query: z.object({
+			limit: z.coerce.number().int().min(1).max(100).optional(),
+		}),
+	},
+	async (ctx) => {
+		const controller = ctx.context.controllers.search as SearchController;
+		const terms = await controller.getPopularTerms(ctx.query.limit ?? 20);
+		return { terms };
+	},
+);

package/src/admin/endpoints/synonyms.ts

@@ -0,0 +1,49 @@
+import { createAdminEndpoint, z } from "@86d-app/core";
+import type { SearchController } from "../../service";
+
+export const listSynonyms = createAdminEndpoint(
+	"/admin/search/synonyms",
+	{ method: "GET" },
+	async (ctx) => {
+		const controller = ctx.context.controllers.search as SearchController;
+		const synonyms = await controller.listSynonyms();
+		return { synonyms };
+	},
+);
+
+export const addSynonym = createAdminEndpoint(
+	"/admin/search/synonyms/add",
+	{
+		method: "POST",
+		body: z.object({
+			term: z.string().min(1).max(200),
+			synonyms: z.array(z.string().min(1).max(200)).min(1).max(50),
+		}),
+	},
+	async (ctx) => {
+		const controller = ctx.context.controllers.search as SearchController;
+		const synonym = await controller.addSynonym(
+			ctx.body.term,
+			ctx.body.synonyms,
+		);
+		return { synonym };
+	},
+);
+
+export const removeSynonym = createAdminEndpoint(
+	"/admin/search/synonyms/:id/delete",
+	{
+		method: "POST",
+		params: z.object({
+			id: z.string(),
+		}),
+	},
+	async (ctx) => {
+		const controller = ctx.context.controllers.search as SearchController;
+		const removed = await controller.removeSynonym(ctx.params.id);
+		if (!removed) {
+			throw new Error("Synonym not found");
+		}
+		return { success: true };
+	},
+);

package/src/admin/endpoints/zero-results.ts

@@ -0,0 +1,17 @@
+import { createAdminEndpoint, z } from "@86d-app/core";
+import type { SearchController } from "../../service";
+
+export const zeroResultsEndpoint = createAdminEndpoint(
+	"/admin/search/zero-results",
+	{
+		method: "GET",
+		query: z.object({
+			limit: z.coerce.number().int().min(1).max(100).optional(),
+		}),
+	},
+	async (ctx) => {
+		const controller = ctx.context.controllers.search as SearchController;
+		const terms = await controller.getZeroResultQueries(ctx.query.limit ?? 20);
+		return { terms };
+	},
+);

package/src/index.ts

@@ -0,0 +1,61 @@
+import type { Module, ModuleConfig, ModuleContext } from "@86d-app/core";
+import { adminEndpoints } from "./admin/endpoints";
+import { searchSchema } from "./schema";
+import { createSearchController } from "./service-impl";
+import { storeEndpoints } from "./store/endpoints";
+
+export type {
+	SearchController,
+	SearchIndexItem,
+	SearchQuery,
+	SearchResult,
+	SearchSynonym,
+} from "./service";
+
+export interface SearchOptions extends ModuleConfig {
+	/** Maximum number of search results per query */
+	maxResults?: number;
+}
+
+export default function search(options?: SearchOptions): Module {
+	return {
+		id: "search",
+		version: "0.0.1",
+		schema: searchSchema,
+		exports: {
+			read: ["searchIndexCount", "popularTerms"],
+		},
+		events: {
+			emits: ["search.queried", "search.indexed", "search.removed"],
+		},
+		init: async (ctx: ModuleContext) => {
+			const controller = createSearchController(ctx.data);
+			return { controllers: { search: controller } };
+		},
+		search: { store: "/search/store-search" },
+		endpoints: {
+			store: storeEndpoints,
+			admin: adminEndpoints,
+		},
+		admin: {
+			pages: [
+				{
+					path: "/admin/search",
+					component: "SearchAnalytics",
+					label: "Search",
+					icon: "MagnifyingGlass",
+					group: "Marketing",
+				},
+			],
+		},
+		store: {
+			pages: [
+				{
+					path: "/search",
+					component: "SearchPage",
+				},
+			],
+		},
+		options,
+	};
+}

package/src/mdx.d.ts

@@ -0,0 +1,5 @@
+declare module "*.mdx" {
+	import type { ComponentType } from "react";
+	const Component: ComponentType<Record<string, unknown>>;
+	export default Component;
+}

package/src/schema.ts

@@ -0,0 +1,48 @@
+import type { ModuleSchema } from "@86d-app/core";
+
+export const searchSchema = {
+	searchIndex: {
+		fields: {
+			id: { type: "string", required: true },
+			entityType: { type: "string", required: true },
+			entityId: { type: "string", required: true },
+			title: { type: "string", required: true },
+			body: { type: "string", required: false },
+			tags: { type: "json", required: false, defaultValue: [] },
+			url: { type: "string", required: true },
+			image: { type: "string", required: false },
+			metadata: { type: "json", required: false, defaultValue: {} },
+			indexedAt: {
+				type: "date",
+				required: true,
+				defaultValue: () => new Date(),
+			},
+		},
+	},
+	searchQuery: {
+		fields: {
+			id: { type: "string", required: true },
+			term: { type: "string", required: true },
+			normalizedTerm: { type: "string", required: true },
+			resultCount: { type: "number", required: true },
+			sessionId: { type: "string", required: false },
+			searchedAt: {
+				type: "date",
+				required: true,
+				defaultValue: () => new Date(),
+			},
+		},
+	},
+	searchSynonym: {
+		fields: {
+			id: { type: "string", required: true },
+			term: { type: "string", required: true },
+			synonyms: { type: "json", required: true },
+			createdAt: {
+				type: "date",
+				required: true,
+				defaultValue: () => new Date(),
+			},
+		},
+	},
+} satisfies ModuleSchema;