@salesforce/ui-bundle-template-app-react-sample-b2e 11.55.0 → 11.56.0

package/dist/force-app/main/default/uiBundles/propertymanagementapp/src/features/search/api/__tests__/searchService.test.ts

@@ -0,0 +1,304 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+/**
+ * Tests for runSearch partial-failure resilience: one source erroring should
+ * not drop the other source's results; errors are returned per-source rather
+ * than throwing at the page level.
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import type { SourceRequest } from "../../adapters/types";
+
+// Mock the platform SDK and adapters
+vi.mock("@salesforce/platform-sdk", () => ({
+	createDataSDK: vi.fn(),
+}));
+
+vi.mock("../../adapters/registry", () => ({
+	getAdapter: vi.fn(),
+}));
+
+vi.mock("../../queryBuilder", () => ({
+	buildSearchQuery: vi.fn(),
+}));
+
+describe("runSearch", () => {
+	let runSearch: typeof import("../searchService").runSearch;
+	let mockGraphqlQuery: ReturnType<typeof vi.fn>;
+	let mockGetAdapter: ReturnType<typeof vi.fn>;
+	let mockBuildSearchQuery: ReturnType<typeof vi.fn>;
+
+	beforeEach(async () => {
+		vi.resetModules();
+
+		const { createDataSDK } = await import("@salesforce/platform-sdk");
+		const { getAdapter } = await import("../../adapters/registry");
+		const { buildSearchQuery } = await import("../../queryBuilder");
+		const { runSearch: importedRunSearch } = await import("../searchService");
+
+		runSearch = importedRunSearch;
+		mockGraphqlQuery = vi.fn();
+		mockGetAdapter = getAdapter as ReturnType<typeof vi.fn>;
+		mockBuildSearchQuery = buildSearchQuery as ReturnType<typeof vi.fn>;
+
+		(createDataSDK as ReturnType<typeof vi.fn>).mockResolvedValue({
+			graphql: {
+				query: mockGraphqlQuery,
+			},
+		});
+
+		mockBuildSearchQuery.mockReturnValue({
+			document: "query Search { ... }",
+			variables: {},
+		});
+	});
+
+	it("returns both results when both sources succeed", async () => {
+		const mockSobjectAdapter = {
+			kind: "sobject",
+			buildRequest: vi.fn(),
+			parseResponse: vi.fn().mockReturnValue({
+				nodes: [{ Id: "001", Name: "Acme" }],
+				pageInfo: { hasNextPage: false, hasPreviousPage: false },
+				totalCount: 1,
+			}),
+		};
+
+		const mockCmsAdapter = {
+			kind: "cms",
+			buildRequest: vi.fn(),
+			parseResponse: vi.fn().mockReturnValue({
+				nodes: [{ managedContentId: "mc1", title: "Annual Report" }],
+				pageInfo: { hasNextPage: false, hasPreviousPage: false },
+				totalCount: 1,
+			}),
+		};
+
+		mockGetAdapter.mockImplementation((kind: string) => {
+			if (kind === "sobject") return mockSobjectAdapter;
+			if (kind === "cms") return mockCmsAdapter;
+			throw new Error(`Unknown kind: ${kind}`);
+		});
+
+		mockGraphqlQuery.mockResolvedValue({
+			data: {
+				uiapi: { query: { accounts: { edges: [] } } },
+				managed_content: { search: { searchContentInChannels: {} } },
+			},
+			errors: undefined,
+		});
+
+		const outcome = await runSearch([
+			{ source: { kind: "sobject", key: "accounts" } },
+			{ source: { kind: "cms", key: "content" } },
+		] as unknown as SourceRequest[]);
+
+		expect(outcome.results).toHaveProperty("accounts");
+		expect(outcome.results).toHaveProperty("content");
+		expect(outcome.errors).toEqual({});
+	});
+
+	it("partial failure: CMS fails, SObject succeeds — returns SObject results + CMS error", async () => {
+		const mockSobjectAdapter = {
+			kind: "sobject",
+			buildRequest: vi.fn(),
+			parseResponse: vi.fn().mockReturnValue({
+				nodes: [{ Id: "001", Name: "Acme" }],
+				pageInfo: { hasNextPage: false, hasPreviousPage: false },
+				totalCount: 1,
+			}),
+		};
+
+		const mockCmsAdapter = {
+			kind: "cms",
+			buildRequest: vi.fn(),
+			parseResponse: vi.fn().mockReturnValue(null), // CMS failed to parse
+		};
+
+		mockGetAdapter.mockImplementation((kind: string) => {
+			if (kind === "sobject") return mockSobjectAdapter;
+			if (kind === "cms") return mockCmsAdapter;
+			throw new Error(`Unknown kind: ${kind}`);
+		});
+
+		mockGraphqlQuery.mockResolvedValue({
+			data: {
+				uiapi: { query: { accounts: { edges: [] } } },
+				managed_content: null, // CMS subtree absent/errored
+			},
+			errors: [{ message: "CMS search failed", path: ["managed_content"] }],
+		});
+
+		const outcome = await runSearch([
+			{ source: { kind: "sobject", key: "accounts" } },
+			{ source: { kind: "cms", key: "content" } },
+		] as unknown as SourceRequest[]);
+
+		// SObject results present
+		expect(outcome.results).toHaveProperty("accounts");
+		expect(outcome.results.accounts.nodes).toHaveLength(1);
+
+		// CMS error attributed
+		expect(outcome.errors).toHaveProperty("content");
+		expect(outcome.errors.content).toContain("CMS search failed");
+
+		// Not a page-level throw
+		expect(Object.keys(outcome.results)).toContain("accounts");
+	});
+
+	it("partial failure: SObject fails, CMS succeeds — returns CMS results + SObject error", async () => {
+		const mockSobjectAdapter = {
+			kind: "sobject",
+			buildRequest: vi.fn(),
+			parseResponse: vi.fn().mockReturnValue(null), // SObject failed
+		};
+
+		const mockCmsAdapter = {
+			kind: "cms",
+			buildRequest: vi.fn(),
+			parseResponse: vi.fn().mockReturnValue({
+				nodes: [{ managedContentId: "mc1", title: "Report" }],
+				pageInfo: { hasNextPage: false, hasPreviousPage: false },
+				totalCount: 1,
+			}),
+		};
+
+		mockGetAdapter.mockImplementation((kind: string) => {
+			if (kind === "sobject") return mockSobjectAdapter;
+			if (kind === "cms") return mockCmsAdapter;
+			throw new Error(`Unknown kind: ${kind}`);
+		});
+
+		mockGraphqlQuery.mockResolvedValue({
+			data: {
+				uiapi: { query: { accounts: null } },
+				managed_content: { search: { searchContentInChannels: {} } },
+			},
+			errors: [{ message: "Account query failed", path: ["uiapi", "query", "accounts"] }],
+		});
+
+		const outcome = await runSearch([
+			{ source: { kind: "sobject", key: "accounts" } },
+			{ source: { kind: "cms", key: "content" } },
+		] as unknown as SourceRequest[]);
+
+		// CMS results present
+		expect(outcome.results).toHaveProperty("content");
+		expect(outcome.results.content.nodes).toHaveLength(1);
+
+		// SObject error attributed
+		expect(outcome.errors).toHaveProperty("accounts");
+		expect(outcome.errors.accounts).toContain("Account query failed");
+
+		// Not a page-level throw
+		expect(Object.keys(outcome.results)).toContain("content");
+	});
+
+	it("whole-request failure (no data at all) throws for page-level error", async () => {
+		mockGraphqlQuery.mockResolvedValue({
+			data: null, // Whole request failed
+			errors: [{ message: "Network timeout" }],
+		});
+
+		await expect(
+			runSearch([{ source: { kind: "sobject", key: "accounts" } }] as unknown as SourceRequest[]),
+		).rejects.toThrow("Network timeout");
+	});
+
+	it("content-type validation error (data:{}, empty paths) is a per-source error, not a page throw", async () => {
+		// Regression: the discovery-driven CMS refetch adds `contentTypes:` to
+		// `searchContentInChannels`. On an org whose backend doesn't accept that
+		// argument, the response is `{ data: {}, errors: [ValidationError …] }`
+		// with an EMPTY `paths` array. Because `data` is `{}` (not null) runSearch
+		// must NOT throw; it records a generic per-source error for the CMS source
+		// so the caller can degrade to the un-narrowed bootstrap results.
+		const mockCmsAdapter = {
+			kind: "cms",
+			buildRequest: vi.fn(),
+			parseResponse: vi.fn().mockReturnValue(null), // {} has no CMS subtree
+		};
+		mockGetAdapter.mockReturnValue(mockCmsAdapter);
+
+		mockGraphqlQuery.mockResolvedValue({
+			data: {},
+			errors: [
+				{
+					extensions: { ErrorType: "ValidationError" },
+					message:
+						"Validation error (UnknownArgument@[managed_content/search/searchContentInChannels]) : Unknown field argument 'contentTypes'",
+					paths: [],
+				},
+			],
+		});
+
+		const outcome = await runSearch([
+			{ source: { kind: "cms", key: "content" } },
+		] as unknown as SourceRequest[]);
+
+		// No throw, no parsed result, and a generic per-source error (empty
+		// `paths` → no attribution match → the generic fallback message).
+		expect(outcome.results).toEqual({});
+		expect(outcome.errors.content).toBe("Search failed for this source.");
+	});
+
+	it("attributes errors correctly by path for multiple SObject sources", async () => {
+		const mockSobjectAdapter = {
+			kind: "sobject",
+			buildRequest: vi.fn(),
+			parseResponse: vi.fn().mockReturnValue(null),
+		};
+
+		mockGetAdapter.mockReturnValue(mockSobjectAdapter);
+
+		mockGraphqlQuery.mockResolvedValue({
+			data: {
+				uiapi: { query: { accounts: null, contacts: null } },
+			},
+			errors: [
+				{ message: "Account error", path: ["uiapi", "query", "accounts"] },
+				{ message: "Contact error", path: ["uiapi", "query", "contacts"] },
+			],
+		});
+
+		const outcome = await runSearch([
+			{ source: { kind: "sobject", key: "accounts" } },
+			{ source: { kind: "sobject", key: "contacts" } },
+		] as unknown as SourceRequest[]);
+
+		expect(outcome.errors.accounts).toContain("Account error");
+		expect(outcome.errors.contacts).toContain("Contact error");
+		expect(outcome.results).toEqual({});
+	});
+
+	it("does not cross-attribute: a source with no matching error path gets a generic message", async () => {
+		const mockSobjectAdapter = {
+			kind: "sobject",
+			buildRequest: vi.fn(),
+			parseResponse: vi.fn().mockReturnValue(null),
+		};
+
+		mockGetAdapter.mockReturnValue(mockSobjectAdapter);
+
+		// Only `accounts` has a matching error path; `contacts` produced no data
+		// but no error path points at it. It must NOT echo the accounts message.
+		mockGraphqlQuery.mockResolvedValue({
+			data: {
+				uiapi: { query: { accounts: null, contacts: null } },
+			},
+			errors: [{ message: "Account error", path: ["uiapi", "query", "accounts"] }],
+		});
+
+		const outcome = await runSearch([
+			{ source: { kind: "sobject", key: "accounts" } },
+			{ source: { kind: "sobject", key: "contacts" } },
+		] as unknown as SourceRequest[]);
+
+		expect(outcome.errors.accounts).toContain("Account error");
+		// The generic per-source fallback — NOT the unrelated "Account error".
+		expect(outcome.errors.contacts).toBe("Search failed for this source.");
+		expect(outcome.errors.contacts).not.toContain("Account error");
+	});
+});

package/dist/force-app/main/default/uiBundles/propertymanagementapp/src/features/search/api/searchService.ts

@@ -1,35 +1,91 @@
 /**
- * Executes a search request and parses results into a per-source map.
+ * Executes a combined search request and parses each source's subtree via its
+ * adapter, with partial-failure resilience.
  *
- * Today there's only one adapter — SObjects via the platform-sdk uiapi GraphQL
- * bridge. Future adapters (CMS, REST, etc.) can run alongside this one and
- * have their results merged into the same `Record<sourceKey, SourceResult>`
- * by the hook.
+ * The combined GraphQL response can carry BOTH partial `data` AND `errors`
+ * (`uiapi` and CMS `managed_content` are independent roots). Rather than
+ * throwing on `response.errors`, we parse each source through
+ * `getAdapter(kind).parseResponse(root, req)`:
+ *   - a `SourceResult` → recorded in `results[key]`.
+ *   - `null` (subtree absent/errored) → the source produced no data; if the
+ *     request as a whole reported GraphQL errors, an attributed message is
+ *     recorded in `errors[key]` so the UI can show a per-source error while
+ *     sibling sources still render.
+ *
+ * Only a whole-request failure — the SDK call rejecting, or a response with no
+ * `data` at all — throws, so `useSearch` surfaces it as a page-level error
+ * (preserving the original network-failure behaviour).
  */
 
 import { createDataSDK } from "@salesforce/platform-sdk";
-import { buildSearchQuery, type SourceRequest } from "../queryBuilder";
+import { buildSearchQuery } from "../queryBuilder";
+import { getAdapter } from "../adapters/registry";
+import type { SourceRequest } from "../adapters/types";
 import type { SourceResult } from "../types";
 
-interface RawSourceResult {
-	edges?: Array<{ node?: unknown }> | null;
-	pageInfo?: {
-		hasNextPage?: boolean | null;
-		hasPreviousPage?: boolean | null;
-		startCursor?: string | null;
-		endCursor?: string | null;
-	} | null;
-	totalCount?: number | null;
+/**
+ * The outcome of a combined `runSearch`: successfully-parsed results plus a
+ * per-source error map. `errors` is keyed by `source.key` and only carries an
+ * entry for a source that failed to produce data (its subtree was absent or
+ * errored). A source appears in at most one of `results` / `errors`.
+ */
+export interface RunSearchOutcome {
+	results: Record<string, SourceResult>;
+	errors: Record<string, string>;
+}
+
+/** Minimal shape of a GraphQL error we can attribute to a source by path. */
+interface GraphQLErrorLike {
+	message?: string | null;
+	path?: Array<string | number> | null;
 }
 
 /**
- * Runs a single multi-aliased GraphQL request against uiapi.query.
+ * Attributes GraphQL errors to a source by matching the error `path` against
+ * the source's location in the document:
+ *   - SObject aliases live under `uiapi.query.<key>`.
+ *   - CMS lives under the root `managed_content` block.
  *
- * Returns a plain object keyed by source.key. A source whose alias is missing
- * from the response (e.g. due to a partial GraphQL error) is omitted; the
- * caller can detect this by `result[sourceKey] == null`.
+ * Returns the joined messages whose `path` matches `request`. When NO path
+ * matches (or paths are absent), returns a GENERIC per-source message rather
+ * than echoing unrelated sources' messages — otherwise one source could display
+ * another's error text (over-broad cross-attribution). The whole-request
+ * (`data == null`) path still joins ALL error messages; that lives in
+ * `runSearch` and is unaffected.
  */
-export async function runSearch(requests: SourceRequest[]): Promise<Record<string, SourceResult>> {
+function attributeError(request: SourceRequest, errors: GraphQLErrorLike[]): string {
+	const kind = request.source.kind;
+	const key = request.source.key;
+
+	const matched = errors.filter((e) => {
+		const path = e.path;
+		if (!path || path.length === 0) return false;
+		if (kind === "cms") {
+			return path[0] === "managed_content";
+		}
+		// SObject: uiapi -> query -> <key>
+		return path[0] === "uiapi" && path[1] === "query" && path[2] === key;
+	});
+
+	// No path matched this source: don't leak sibling sources' messages — fall
+	// back to a generic per-source explanation.
+	if (matched.length === 0) {
+		return "Search failed for this source.";
+	}
+
+	const message = matched
+		.map((e) => e.message)
+		.filter((m): m is string => !!m)
+		.join("; ");
+	return message || "Search failed for this source.";
+}
+
+/**
+ * Runs one combined multi-source GraphQL request. Returns `{ results, errors }`
+ * (never throws on partial GraphQL errors); throws only on a whole-request /
+ * network failure.
+ */
+export async function runSearch(requests: SourceRequest[]): Promise<RunSearchOutcome> {
 	const { document, variables } = buildSearchQuery(requests);
 
 	const data = await createDataSDK();
@@ -38,34 +94,43 @@ export async function runSearch(requests: SourceRequest[]): Promise<Record<strin
 		variables,
 	});
 
-	if (response.errors?.length) {
-		throw new Error(response.errors.map((e) => e.message).join("; "));
+	const root = response.data as Record<string, unknown> | undefined;
+	const gqlErrors = (response.errors ?? []) as GraphQLErrorLike[];
+
+	// Whole-request failure: no data at all. Surface as a page-level error
+	// (preserves the original network-failure behaviour).
+	if (root == null) {
+		const message = gqlErrors
+			.map((e) => e.message)
+			.filter((m): m is string => !!m)
+			.join("; ");
+		throw new Error(message || "Unified search failed");
 	}
 
-	const root = response.data as Record<string, unknown> | undefined;
-	const queryRoot = (root?.uiapi as Record<string, unknown> | undefined)?.query as
-		| Record<string, RawSourceResult | null | undefined>
-		| undefined;
+	const results: Record<string, SourceResult> = {};
+	const errors: Record<string, string> = {};
 
-	const out: Record<string, SourceResult> = {};
 	for (const request of requests) {
-		const raw = queryRoot?.[request.source.key];
-		if (raw == null) continue;
-		const nodes = (raw.edges ?? [])
-			.map((edge) => edge?.node)
-			.filter((node): node is unknown => node != null);
-		out[request.source.key] = {
-			nodes,
-			pageInfo: raw.pageInfo
-				? {
-						hasNextPage: raw.pageInfo.hasNextPage ?? false,
-						hasPreviousPage: raw.pageInfo.hasPreviousPage ?? false,
-						startCursor: raw.pageInfo.startCursor ?? null,
-						endCursor: raw.pageInfo.endCursor ?? null,
-					}
-				: null,
-			totalCount: raw.totalCount ?? null,
-		};
+		const key = request.source.key;
+		let parsed: SourceResult | null = null;
+		try {
+			parsed = getAdapter(request.source.kind).parseResponse(root, request);
+		} catch {
+			// An adapter that throws while parsing its own subtree is a
+			// per-source failure, not a page-level one.
+			parsed = null;
+		}
+
+		if (parsed != null) {
+			results[key] = parsed;
+		} else if (gqlErrors.length > 0) {
+			// No data for this source AND the request reported errors — attribute
+			// a message so the UI can show a per-source error.
+			errors[key] = attributeError(request, gqlErrors);
+		}
+		// else: no data and no errors — the source simply returned nothing;
+		// leave it absent from both maps (empty result, no error).
 	}
-	return out;
+
+	return { results, errors };
 }

package/dist/force-app/main/default/uiBundles/propertymanagementapp/src/features/search/components/GlobalSearchBox.tsx

@@ -0,0 +1,98 @@
+/**
+ * GlobalSearchBox — pure launcher component for global search.
+ *
+ * A self-contained search input + button that navigates to `/search?q=...`
+ * when the user submits a query of at least MIN_QUERY_LENGTH characters.
+ *
+ * Props are purely cosmetic (className, placeholder, autoFocus) — all behavior
+ * (the gate, the route, the query key) is owned by this component, not the caller.
+ *
+ * Usage:
+ * ```tsx
+ * import { GlobalSearchBox } from "../features/search";
+ * <GlobalSearchBox className="mb-8" placeholder="Search everything..." />
+ * ```
+ */
+
+import { Search } from "lucide-react";
+import { useId, useState } from "react";
+import { useNavigate } from "react-router";
+import { Input } from "../../../components/ui/input";
+import { Button } from "../../../components/ui/button";
+import { GLOBAL_QUERY_KEY } from "../utils/filterUtils";
+import { MIN_QUERY_LENGTH } from "../constants";
+
+export interface GlobalSearchBoxProps {
+	/** Optional CSS class for container styling/placement. */
+	className?: string;
+	/** Placeholder text for the search input. */
+	placeholder?: string;
+	/** Whether the input should autofocus on mount. */
+	autoFocus?: boolean;
+	/**
+	 * Accessible (screen-reader) label for the input. Exposed as a prop so
+	 * callers can localize it; defaults to English. */
+	label?: string;
+	/** Visible text for the submit button. Exposed for localization. */
+	submitLabel?: string;
+	/**
+	 * Minimum length of keyword required by search. `{min}` is replaced with
+	 * {@link MIN_QUERY_LENGTH}. Exposed for localization. */
+	minLengthHint?: string;
+}
+
+export function GlobalSearchBox({
+	className,
+	placeholder = "Search…",
+	autoFocus,
+	label = "Search",
+	submitLabel = "Search",
+	minLengthHint = "Enter at least {min} characters to search.",
+}: GlobalSearchBoxProps) {
+	const navigate = useNavigate();
+	const [text, setText] = useState("");
+	const inputId = useId();
+	const hintId = useId();
+
+	const canSearch = text.trim().length >= MIN_QUERY_LENGTH;
+	const hintText = minLengthHint.replace("{min}", String(MIN_QUERY_LENGTH));
+
+	const handleSubmit = (e: React.FormEvent<HTMLFormElement>) => {
+		e.preventDefault();
+		if (!canSearch) return;
+		const params = `?${GLOBAL_QUERY_KEY}=${encodeURIComponent(text.trim())}`;
+		navigate(`/search${params}`);
+	};
+
+	return (
+		<form onSubmit={handleSubmit} className={className} role="search">
+			<label htmlFor={inputId} className="sr-only">
+				{label}
+			</label>
+			<div className="flex gap-2">
+				<div className="relative flex-1">
+					<Search
+						aria-hidden="true"
+						className="absolute left-3 top-1/2 -translate-y-1/2 h-4 w-4 text-muted-foreground"
+					/>
+					<Input
+						id={inputId}
+						type="text"
+						value={text}
+						onChange={(e) => setText(e.target.value)}
+						placeholder={placeholder}
+						autoFocus={autoFocus}
+						className="pl-9"
+						aria-describedby={hintId}
+					/>
+				</div>
+				<Button type="submit" disabled={!canSearch}>
+					{submitLabel}
+				</Button>
+			</div>
+			<p id={hintId} className="sr-only">
+				{hintText}
+			</p>
+		</form>
+	);
+}