@salesforce/ui-bundle-template-app-react-sample-b2e 11.55.1 → 11.56.1

package/dist/force-app/main/default/uiBundles/propertymanagementapp/src/features/search/adapters/cms/parseResponse.ts

@@ -0,0 +1,65 @@
+/**
+ * CMS response parser: `root.managed_content.search.searchContentInChannels` →
+ * {@link SourceResult}, normalising CMS offset paging onto the common
+ * cursor-shaped {@link SourcePageInfo}.
+ *
+ * Partial-failure leniency: every level is guarded and the function returns
+ * `null` — never throws — when its subtree is absent or errored.
+ *
+ * Offset → pageInfo:
+ *   - `totalCount     = total`
+ *   - `hasNextPage    = offset + items.length < total`
+ *   - `hasPreviousPage= offset > 0`
+ *   - `endCursor      = String(offset + pageSize)`  (the caller's request page size)
+ *   - `startCursor    = String(offset)`
+ */
+
+import type { CmsSourceConfig, CmsSearchResponse } from "./types";
+import type { SourceResult } from "../../types";
+import type { SourceRequest } from "../types";
+
+/** Narrows an unknown value to a plain object (or `undefined`). */
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+	return value != null && typeof value === "object"
+		? (value as Record<string, unknown>)
+		: undefined;
+}
+
+/**
+ * Reads the CMS subtree from the full response `data` root and maps it to a
+ * {@link SourceResult}. Returns `null` when the subtree is absent/errored.
+ *
+ * `pageSize` for the cursor math is taken from the request (the page size we
+ * asked for), matching `buildRequest`'s `$cmsLimit = request.pageSize`, so
+ * next/prev advances the offset by exactly one page.
+ */
+export function parseCmsResponse(
+	root: Record<string, unknown>,
+	request: SourceRequest<CmsSourceConfig>,
+): SourceResult | null {
+	const managedContent = asRecord(root?.managed_content);
+	const search = asRecord(managedContent?.search);
+	const raw = asRecord(search?.searchContentInChannels);
+	if (!raw) return null;
+
+	const response = raw as unknown as CmsSearchResponse;
+
+	const items = Array.isArray(response.items) ? response.items : [];
+	const total = typeof response.total === "number" ? response.total : null;
+	const offset = typeof response.offset === "number" ? response.offset : 0;
+	const pageSize = request.pageSize;
+
+	const hasNextPage = total != null ? offset + items.length < total : false;
+	const hasPreviousPage = offset > 0;
+
+	return {
+		nodes: items,
+		pageInfo: {
+			hasNextPage,
+			hasPreviousPage,
+			startCursor: String(offset),
+			endCursor: String(offset + pageSize),
+		},
+		totalCount: total,
+	};
+}

package/dist/force-app/main/default/uiBundles/propertymanagementapp/src/features/search/adapters/cms/searchChannel.ts

@@ -0,0 +1,15 @@
+import { getCurrentApp } from "@salesforce/platform-sdk";
+
+/** Returns the UIBundle id for CMS search, resolved from the running app. */
+export async function getUIBundleId(): Promise<string> {
+	const app = await getCurrentApp();
+	return app.identity?.bundleId ?? "";
+}
+
+/** Shape guard for a UIBundle record id (9YE + 12-15 alphanumerics). */
+export const UI_BUNDLE_ID_PATTERN = /^9YE[a-zA-Z0-9]{12,15}$/;
+
+/** True when `id` is a well-formed (9YE-shaped) UIBundle id. */
+export function isConfiguredUIBundleId(id: string): boolean {
+	return UI_BUNDLE_ID_PATTERN.test(id.trim());
+}

package/dist/force-app/main/default/uiBundles/propertymanagementapp/src/features/search/adapters/cms/types.ts

@@ -0,0 +1,66 @@
+/**
+ * CMS source config + the response shapes returned by
+ * `managed_content.search.searchContentInChannels`.
+ */
+
+export interface CmsChannelDetails {
+	id: string;
+	name: string;
+	type?: string;
+}
+
+export interface CmsChannelDeliveryDetails {
+	contentUrl?: string;
+	publishedDate?: string;
+	managedContentChannelDetails: CmsChannelDetails;
+}
+
+export interface CmsSearchItem {
+	managedContentId: string;
+	managedContentKey: string;
+	title: string;
+	contentType: string;
+	language?: string;
+	highlightedSnippet?: string;
+	managedContentChannelDeliveryDetails: CmsChannelDeliveryDetails[];
+}
+
+export interface CmsSearchResponse {
+	total: number;
+	offset: number;
+	pageSize: number;
+	items: CmsSearchItem[];
+}
+
+/**
+ * Configuration for one CMS source in a search experience.
+ *
+ * Deliberately minimal — unlike an SObject source (which hardcodes an object
+ * name, searchable/display fields, filters, etc.), a CMS source hardcodes
+ * nothing about the CMS data. The search channel id comes from
+ * `searchChannel.getUIBundleId()`; content types are discovered at runtime from
+ * the search results. This config only names the source and (optionally)
+ * describes how to build a result link.
+ */
+export interface CmsSourceConfig {
+	/** Discriminator — selects the CMS runtime adapter. */
+	kind: "cms";
+	/**
+	 * Stable identifier. Used as the scope key, the result-map key, and the
+	 * prefix for CMS content-type scope entries (`"<key>:<fqn>"`). Must match
+	 * `/^[A-Za-z_][A-Za-z0-9_]*$/`.
+	 */
+	key: string;
+	/** Plural display label — dropdown entry + section header, e.g. "Content". */
+	label: string;
+	/** Singular label for the per-card source badge. Falls back to `label`. */
+	labelSingular?: string;
+	/**
+	 * Optional URL pattern used by `CmsResultRow` to build a result link.
+	 * Tokens: `:id` (managedContentId), `:key` (managedContentKey),
+	 * `:contentType` (contentType). When omitted, the row falls back to
+	 * `/content/:contentType/:id`.
+	 */
+	routePattern?: string;
+	// NO channelId, NO content types, NO displayFields — all resolved at runtime.
+}

package/dist/force-app/main/default/uiBundles/propertymanagementapp/src/features/search/adapters/registry.ts

@@ -0,0 +1,38 @@
+/**
+ * Adapter registry — maps a source `kind` to its runtime {@link SourceAdapter}.
+ *
+ * The core query builder and response parser call {@link getAdapter} for each
+ * source instead of hard-coding SObject logic, so a new backend is added purely
+ * by registering an adapter here (plus its `kind` in the `SourceConfig` union).
+ *
+ * The `cmsAdapter` is authored by the CMS implementer at `./cms` (exported as
+ * `cmsAdapter`); it is imported and registered here, never stubbed.
+ */
+
+import type { SourceConfig } from "../types";
+import type { SourceAdapter } from "./types";
+import { sObjectAdapter } from "./sobject";
+import { cmsAdapter } from "./cms";
+
+/**
+ * Registry keyed by `SourceConfig["kind"]`. Each entry is the adapter narrowed
+ * to the matching config variant; `getAdapter` widens back to the base
+ * `SourceAdapter` for kind-agnostic callers.
+ */
+const REGISTRY: { [K in SourceConfig["kind"]]: SourceAdapter<Extract<SourceConfig, { kind: K }>> } =
+	{
+		sobject: sObjectAdapter,
+		cms: cmsAdapter,
+	};
+
+/**
+ * Returns the adapter registered for `kind`. Throws on an unknown kind (a
+ * config carrying a `kind` with no adapter is a programming error).
+ */
+export function getAdapter(kind: SourceConfig["kind"]): SourceAdapter {
+	const adapter = REGISTRY[kind];
+	if (!adapter) {
+		throw new Error(`No search adapter registered for source kind "${kind}".`);
+	}
+	return adapter as SourceAdapter;
+}

package/dist/force-app/main/default/uiBundles/propertymanagementapp/src/features/search/adapters/sobject/index.ts

@@ -0,0 +1,19 @@
+/**
+ * SObject adapter — the original uiapi GraphQL bridge, now behind the
+ * kind-agnostic {@link SourceAdapter} contract.
+ *
+ * `buildRequest` delegates to the extracted fragment builder and
+ * `parseResponse` to the extracted response parser. Both preserve the original
+ * behaviour byte-for-byte; this file is only the wiring.
+ */
+
+import type { SObjectSourceConfig } from "../../types";
+import type { SourceAdapter } from "../types";
+import { buildSObjectFragment } from "./queryFragment";
+import { parseSObjectResponse } from "./parseResponse";
+
+export const sObjectAdapter: SourceAdapter<SObjectSourceConfig> = {
+	kind: "sobject",
+	buildRequest: buildSObjectFragment,
+	parseResponse: parseSObjectResponse,
+};

package/dist/force-app/main/default/uiBundles/propertymanagementapp/src/features/search/adapters/sobject/parseResponse.ts

@@ -0,0 +1,56 @@
+/**
+ * SObject response parser.
+ *
+ * Extracted verbatim from `searchService.ts`: the `RawSourceResult` interface
+ * and the `edges → nodes / pageInfo / totalCount` mapping. Reads its subtree
+ * from `root.uiapi.query[source.key]` and returns `null` when the alias is
+ * absent (partial-failure leniency), never throwing.
+ */
+
+import type { SObjectSourceConfig, SourceResult } from "../../types";
+import type { SourceRequest } 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;
+}
+
+/**
+ * Maps `root.uiapi.query[source.key]` (an `edges`/`pageInfo`/`totalCount`
+ * subtree) to a {@link SourceResult}. Returns `null` when the alias is missing
+ * from the response (e.g. a partial GraphQL error blanked this source only).
+ */
+export function parseSObjectResponse(
+	root: Record<string, unknown>,
+	request: SourceRequest<SObjectSourceConfig>,
+): SourceResult | null {
+	const queryRoot = (root?.uiapi as Record<string, unknown> | undefined)?.query as
+		| Record<string, RawSourceResult | null | undefined>
+		| undefined;
+
+	const raw = queryRoot?.[request.source.key];
+	if (raw == null) return null;
+
+	const nodes = (raw.edges ?? [])
+		.map((edge) => edge?.node)
+		.filter((node): node is unknown => node != null);
+
+	return {
+		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,
+	};
+}

package/dist/force-app/main/default/uiBundles/propertymanagementapp/src/features/search/adapters/sobject/queryFragment.ts

@@ -0,0 +1,141 @@
+/**
+ * SObject fragment builder.
+ *
+ * Extracted verbatim from `queryBuilder.ts`: `buildSelectionBody`,
+ * `renderField`, `buildSourceWhere`, `assertValidKey`, `KEY_PATTERN`, and the
+ * per-source variable/selection assembly. Emits one `QueryFragmentContribution`
+ * with `placement: "uiapi.query"` — the `${key}: ${objectName}(...) { … }`
+ * selection, its 4 per-source variable declarations, and their 4 values.
+ *
+ * Behaviour is byte-for-byte equivalent to the original inline logic; this is a
+ * move, not a rewrite.
+ *
+ * Selection sets are generated from `displayFields`:
+ *   - string `"Name"` → `Name @optional { value displayValue }`
+ *   - `{ name, raw: true }` → `Name`
+ *   - `{ name, subfields }` → nested `Name @optional { ... }`
+ *
+ * The `idField` (default "Id") is always emitted; it is **not** wrapped
+ * because uiapi's Id is a scalar.
+ */
+
+import {
+	buildFilter,
+	buildGlobalQueryClause,
+	type ActiveFilterValue,
+} from "../../utils/filterUtils";
+import { buildOrderBy } from "../../utils/sortUtils";
+import type { DisplayField, SObjectSourceConfig } from "../../types";
+import type { QueryFragmentContribution, SourceRequest } from "../types";
+
+const KEY_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+
+function assertValidKey(key: string): void {
+	if (!KEY_PATTERN.test(key)) {
+		throw new Error(
+			`Invalid source key "${key}". Must match /^[A-Za-z_][A-Za-z0-9_]*$/ to be a valid GraphQL alias and variable prefix.`,
+		);
+	}
+}
+
+/**
+ * Combines a per-source structured-filter clause with the global-q `or` clause.
+ * Returns `undefined` when neither side has any constraints.
+ */
+function buildSourceWhere(
+	source: SObjectSourceConfig,
+	q: string,
+	filters: ActiveFilterValue[],
+): unknown {
+	const clauses: unknown[] = [];
+	const globalClause = buildGlobalQueryClause(q, source.searchableFields);
+	if (globalClause) clauses.push(globalClause);
+	const structured = buildFilter(filters, source.filterBy ?? []);
+	if (structured) clauses.push(structured);
+	if (clauses.length === 0) return undefined;
+	if (clauses.length === 1) return clauses[0];
+	return { and: clauses };
+}
+
+function buildSelectionBody(source: SObjectSourceConfig): string {
+	const idField = source.idField ?? "Id";
+	const fieldLines = [`    ${idField}`];
+	for (const field of source.displayFields) {
+		fieldLines.push(...renderField(field, "    "));
+	}
+	return [
+		`  edges { node {`,
+		...fieldLines,
+		`  } }`,
+		`  pageInfo { hasNextPage hasPreviousPage startCursor endCursor }`,
+		`  totalCount`,
+	].join("\n");
+}
+
+function renderField(field: DisplayField, indentStr: string): string[] {
+	if (typeof field === "string") {
+		return [`${indentStr}${field} @optional { value displayValue }`];
+	}
+	if ("raw" in field) {
+		return [`${indentStr}${field.name}`];
+	}
+	const lines = [`${indentStr}${field.name} @optional {`];
+	for (const sub of field.subfields) {
+		lines.push(...renderField(sub, indentStr + "  "));
+	}
+	lines.push(`${indentStr}}`);
+	return lines;
+}
+
+/**
+ * Builds one SObject source's `QueryFragmentContribution`.
+ *
+ * The fragment is the `${key}: ${objectName}(...) { … }` selection that lives
+ * inside `uiapi.query`; the 4 declarations/values are the per-source
+ * `first / after / where / orderBy` variables. Output matches the original
+ * inline builder exactly.
+ */
+export function buildSObjectFragment(
+	request: SourceRequest<SObjectSourceConfig>,
+): QueryFragmentContribution {
+	const { source } = request;
+	assertValidKey(source.key);
+
+	const firstVar = `${source.key}_first`;
+	const afterVar = `${source.key}_after`;
+	const whereVar = `${source.key}_where`;
+	const orderByVar = `${source.key}_orderBy`;
+	const whereType = source.whereTypeName ?? `${source.objectName}_Filter`;
+	const orderByType = source.orderByTypeName ?? `${source.objectName}_OrderBy`;
+
+	const variableDeclarations = [
+		`$${firstVar}: Int`,
+		`$${afterVar}: String`,
+		`$${whereVar}: ${whereType}`,
+		`$${orderByVar}: ${orderByType}`,
+	];
+
+	const fragment =
+		`${source.key}: ${source.objectName}(` +
+		`first: $${firstVar}, ` +
+		`after: $${afterVar}, ` +
+		`where: $${whereVar}, ` +
+		`orderBy: $${orderByVar}` +
+		`) {\n` +
+		buildSelectionBody(source) +
+		`\n}`;
+
+	const variables: Record<string, unknown> = {
+		[firstVar]: request.pageSize,
+		[afterVar]: request.afterCursor ?? null,
+		[whereVar]: buildSourceWhere(source, request.q, request.filters) ?? null,
+		[orderByVar]: buildOrderBy(request.sort) ?? null,
+	};
+
+	return {
+		variableDeclarations,
+		variables,
+		placement: "uiapi.query",
+		fragment,
+	};
+}

package/dist/force-app/main/default/uiBundles/propertymanagementapp/src/features/search/adapters/types.ts

@@ -0,0 +1,101 @@
+/**
+ * Kind-agnostic adapter contracts for unified (multi-source) search.
+ *
+ * Every searchable backend ("sobject", "cms", …) is fronted by a
+ * {@link SourceAdapter}. The core query builder and result parser are
+ * completely kind-agnostic: they dispatch to the adapter registered for a
+ * source's `kind`, so a new backend plugs in by adding a `kind` + an adapter,
+ * never by touching the common builder/parser or any consumer.
+ *
+ *  - {@link SourceAdapter.buildRequest} contributes a {@link QueryFragmentContribution}
+ *    (its GraphQL fragment, variable declarations, and variable values) that the
+ *    builder assembles into one combined document.
+ *  - {@link SourceAdapter.parseResponse} receives the full response `data` root
+ *    and extracts this source's `SourceResult`, returning `null` (never
+ *    throwing) when its own subtree is absent or errored — this is what lets
+ *    sources fail independently (partial-failure resilience).
+ */
+
+import type { SourceConfig, SourceResult } from "../types";
+import type { ActiveFilterValue } from "../utils/filterUtils";
+import type { SortState } from "../utils/sortUtils";
+
+/**
+ * One source's contribution to the combined GraphQL document.
+ *
+ * The builder concatenates every source's `variableDeclarations` into the
+ * `query Search(...)` header and merges every source's `variables` into one
+ * flat map. Fragments are placed by `placement`:
+ *   - `"uiapi.query"` → inside the shared `uiapi { query { … } }` block.
+ *   - `"root"`        → a sibling of `uiapi` at the document root (e.g. the CMS
+ *     `managed_content { … }` block).
+ *
+ * A contribution MAY declare zero extra variables (e.g. the CMS bootstrap call
+ * omits `$cmsContentTypeFQNs` entirely). The builder handles declaration lists of
+ * differing lengths, so an unused/undeclared variable is never emitted.
+ */
+export interface QueryFragmentContribution {
+	/** Namespaced GraphQL variable declarations, e.g. `"$cmsKeyword: String!"`. */
+	variableDeclarations: string[];
+	/** Values for the declared variables, keyed by (unprefixed) variable name. */
+	variables: Record<string, unknown>;
+	/** Where the `fragment` is spliced into the combined document. */
+	placement: "uiapi.query" | "root";
+	/** The GraphQL selection fragment (unindented; the builder indents it). */
+	fragment: string;
+}
+
+/**
+ * A per-source search request. Generic over the source config so an adapter can
+ * narrow to its own config kind (e.g. `SourceRequest<CmsSourceConfig>`).
+ *
+ * The base fields (`source`/`q`/`filters`/`sort`/`pageSize`/`afterCursor`) are
+ * kind-agnostic. The trailing fields are optional and only populated for the
+ * kinds that need them; the sync query builder never resolves async values, so
+ * anything async (e.g. the CMS UIBundle id) is resolved by the caller and
+ * threaded in here.
+ */
+export interface SourceRequest<T extends SourceConfig = SourceConfig> {
+	/** The config for the source this request targets. */
+	source: T;
+	/** The global search term, broadcast to every source. */
+	q: string;
+	/** Active structured filters (SObject-relevant; other kinds may ignore). */
+	filters: ActiveFilterValue[];
+	/** Active sort (SObject-relevant; other kinds may ignore). */
+	sort: SortState | null;
+	/** Page size for this fetch (validated against `pageSizeOptions` upstream). */
+	pageSize: number;
+	/** Opaque forward cursor for this fetch (CMS decodes it to an offset). */
+	afterCursor: string | undefined;
+	/**
+	 * CMS-only, optional. Present (non-null, non-empty) only when content types
+	 * are known/selected; absent on the bootstrap call so the CMS adapter omits
+	 * `$cmsContentTypeFQNs` entirely.
+	 */
+	contentTypes?: string[] | null;
+	/**
+	 * CMS-only, optional. The resolved UIBundle id fed into the CMS search
+	 * query. Resolved by the caller (async `getUIBundleId()`) BEFORE the sync
+	 * query builder runs, then threaded in here so `buildRequest` stays
+	 * synchronous. Ignored by non-CMS adapters.
+	 */
+	uiBundleId?: string;
+}
+
+/**
+ * Runtime adapter for one source `kind`. Bridges a kind-agnostic
+ * {@link SourceRequest} to a GraphQL fragment and back to a {@link SourceResult}.
+ */
+export interface SourceAdapter<T extends SourceConfig = SourceConfig> {
+	/** The `kind` discriminator this adapter handles. */
+	readonly kind: T["kind"];
+	/** Build this source's fragment/variables contribution for the combined doc. */
+	buildRequest(request: SourceRequest<T>): QueryFragmentContribution;
+	/**
+	 * Extract this source's result from the full response `data` root. Returns
+	 * `null` when the source's own subtree is absent or errored — never throws
+	 * for a partial failure.
+	 */
+	parseResponse(root: Record<string, unknown>, request: SourceRequest<T>): SourceResult | null;
+}