feat(housekeeping): deliver economy vertical

src/features/housekeeping/domains/economy/search.ts

@@ -0,0 +1,120 @@
+import { PERMS } from "@/lib/permission-slugs";
+import { authorizeHousekeeping } from "../../foundation/authorization";
+import { satisfiesCapability } from "../../foundation/capability-context";
+import {
+	anyCapability,
+	type CapabilityRequirement,
+	fail,
+	type HousekeepingCapabilityContext,
+	type HousekeepingSearchProvider,
+	ok,
+} from "../../foundation/contracts";
+import { isSafeHousekeepingHref } from "../../foundation/housekeeping-href";
+
+export const ECONOMY_SEARCH_PROVIDER_IDS = [
+	"economy.catalog-pages",
+	"economy.items",
+	"economy.transactions",
+] as const;
+
+export interface EconomySearchCandidate {
+	readonly id: string;
+	readonly title: string;
+	readonly description?: string;
+	readonly href: string;
+	readonly capability: CapabilityRequirement;
+}
+
+type EconomySearchLoader = (
+	context: HousekeepingCapabilityContext,
+	term: string,
+	limit: number,
+) => Promise<readonly EconomySearchCandidate[]>;
+
+export interface EconomySearchAdapters {
+	readonly catalogPages: EconomySearchLoader;
+	readonly items: EconomySearchLoader;
+	readonly transactions: EconomySearchLoader;
+}
+
+function createProvider(
+	id: (typeof ECONOMY_SEARCH_PROVIDER_IDS)[number],
+	capability: CapabilityRequirement,
+	load: EconomySearchLoader,
+): HousekeepingSearchProvider {
+	return {
+		id,
+		owner: "economy",
+		capability,
+		async search(context, input) {
+			const authorization = authorizeHousekeeping(context, capability);
+			if (!authorization.ok) return authorization;
+			const limit = Number.isFinite(input.limit)
+				? Math.min(25, Math.max(1, Math.trunc(input.limit)))
+				: 25;
+			const term = input.term.normalize("NFC").trim().slice(0, 128);
+			try {
+				const candidates = await load(context, term, limit);
+				return ok(
+					candidates
+						.filter(
+							(candidate) =>
+								isSafeHousekeepingHref(candidate.href) &&
+								satisfiesCapability(context, candidate.capability),
+						)
+						.slice(0, limit)
+						.map((candidate) => ({
+							...candidate,
+							domain: "economy" as const,
+							type: "entity" as const,
+							href: candidate.href as `/ase/${string}`,
+						})),
+					authorization.correlationId,
+				);
+			} catch {
+				return fail(
+					"DEPENDENCY_UNAVAILABLE",
+					"errors.housekeeping.dependencyUnavailable",
+					authorization.correlationId,
+				);
+			}
+		},
+	};
+}
+
+export function createEconomySearchProviders(
+	adapters: EconomySearchAdapters,
+): readonly HousekeepingSearchProvider[] {
+	return [
+		createProvider(
+			"economy.catalog-pages",
+			anyCapability(PERMS.CATALOG_VIEW),
+			adapters.catalogPages,
+		),
+		createProvider(
+			"economy.items",
+			anyCapability(PERMS.CATALOG_VIEW),
+			adapters.items,
+		),
+		createProvider(
+			"economy.transactions",
+			anyCapability(PERMS.SHOP_VIEW),
+			adapters.transactions,
+		),
+	];
+}
+
+export const ECONOMY_SEARCH_PROVIDERS = createEconomySearchProviders({
+	async catalogPages(context, term, limit) {
+		const { loadEconomySearchCandidates } = await import("./search-production");
+		return loadEconomySearchCandidates("catalog-pages", context, term, limit);
+	},
+	async items(context, term, limit) {
+		const { loadEconomySearchCandidates } = await import("./search-production");
+		return loadEconomySearchCandidates("items", context, term, limit);
+	},
+	async transactions(context, term, limit) {
+		const { loadEconomySearchCandidates } = await import("./search-production");
+		return loadEconomySearchCandidates("transactions", context, term, limit);
+	},
+});