@salesforce/ui-bundle-template-feature-angular-search 0.0.0-stage → 12.14.0

package/dist/force-app/main/default/uiBundles/feature-angular-search/src/app/features/search/filters/text-filter.ts

@@ -0,0 +1,70 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+import {
+	ChangeDetectionStrategy,
+	Component,
+	DestroyRef,
+	effect,
+	inject,
+	input,
+	output,
+	signal,
+	untracked,
+} from "@angular/core";
+import { takeUntilDestroyed } from "@angular/core/rxjs-interop";
+import { Subject } from "rxjs";
+import { debounceTime } from "rxjs/operators";
+import { InputComponent } from "../../../components/ui/input/input";
+import { FILTER_DEBOUNCE_MS, uniqueFilterId, type FilterValue } from "./filter-types";
+import { FilterFieldWrapperComponent } from "./filter-field-wrapper";
+
+/**
+ * Free-text filter. Keystrokes update a local draft immediately and are
+ * emitted on a trailing {@link FILTER_DEBOUNCE_MS}ms debounce; an empty string
+ * emits `undefined` (clear).
+ */
+@Component({
+	selector: "app-text-filter",
+	changeDetection: ChangeDetectionStrategy.OnPush,
+	imports: [InputComponent, FilterFieldWrapperComponent],
+	templateUrl: "./text-filter.html",
+})
+export class TextFilterComponent {
+	private readonly destroyRef = inject(DestroyRef);
+
+	readonly label = input.required<string>();
+	readonly value = input<FilterValue | undefined>(undefined);
+	readonly placeholder = input<string | undefined>(undefined);
+	readonly helpText = input<string | undefined>(undefined);
+	readonly valueChange = output<FilterValue | undefined>();
+
+	protected readonly inputId = uniqueFilterId("filter-text");
+	protected readonly draft = signal("");
+	private readonly commit$ = new Subject<string>();
+
+	constructor() {
+		this.commit$
+			.pipe(debounceTime(FILTER_DEBOUNCE_MS), takeUntilDestroyed(this.destroyRef))
+			.subscribe((v) => this.valueChange.emit(v ? { value: v } : undefined));
+
+		// Re-seed the draft when the bound value changes externally (URL restore, reset).
+		effect(() => {
+			const external = this.value()?.value ?? "";
+			untracked(() => {
+				if (external !== this.draft()) this.draft.set(external);
+			});
+		});
+	}
+
+	protected onInput(v: string): void {
+		this.draft.set(v);
+		this.commit$.next(v);
+	}
+
+	protected placeholderText(): string {
+		return this.placeholder() ?? `Filter by ${this.label().toLowerCase()}...`;
+	}
+}

package/dist/force-app/main/default/uiBundles/feature-angular-search/src/app/features/search/index.ts

@@ -0,0 +1,55 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+export * from "./types";
+export * from "./constants";
+export * from "./utils/debounce";
+export * from "./utils/field-utils";
+export * from "./utils/filter-utils";
+export * from "./utils/sort-utils";
+export * from "./utils/scope-utils";
+export * from "./utils/merge-utils";
+export * from "./utils/identifier";
+export * from "./utils/validate-config";
+export * from "./query/build-search-query";
+export type { QueryFragmentContribution, SourceAdapter } from "./adapters/types";
+export { getAdapter } from "./adapters/registry";
+export { parseSearchResponse, type GraphQLErrorLike } from "./api/search-response";
+export { SearchService } from "./api/search.service";
+
+// State
+export { SearchStateService } from "./state/search-state.service";
+export type {
+	RestrictTo,
+	SearchInitOptions,
+	SourceLocalState,
+	SourceView,
+} from "./state/search-state.types";
+export { activeTypeFor, toActiveFilter, toFilterValue } from "./state/filter-mapping";
+
+// Per-source result templates (Angular's `renderResult`)
+export {
+	SearchResultTemplateDirective,
+	type SearchResultContext,
+} from "./directives/search-result-template/search-result-template";
+
+// Components
+export { SearchComponent } from "./components/search/search";
+export { ScopeSelectorComponent, type ScopeOption } from "./components/scope/scope-selector";
+export { SearchResultsComponent } from "./components/results/search-results";
+export { MergedSearchResultsComponent } from "./components/results/merged-search-results";
+export { SourceSectionComponent } from "./components/results/source-section";
+export { DefaultResultRowComponent } from "./components/results/default-result-row";
+export { ResultItemComponent, type ResultTemplates } from "./components/results/result-item";
+export { DefaultFilterPanelComponent } from "./components/filter-panel/default-filter-panel";
+export { FilterBoxComponent } from "./components/filter-panel/filter-box";
+export { GlobalSearchBoxComponent } from "./components/global-search-box/global-search-box";
+export { SearchBarComponent } from "./components/search-bar/search-bar";
+export { SortControlComponent } from "./components/sort-control/sort-control";
+export { ActiveFiltersComponent } from "./components/active-filters/active-filters";
+
+// Starter config for the shipped /search page
+export { defaultSearchConfig } from "./default-search-config";

package/dist/force-app/main/default/uiBundles/feature-angular-search/src/app/features/search/query/build-search-query.spec.ts

@@ -0,0 +1,157 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+import { describe, it, expect } from "vitest";
+import { buildSearchQuery } from "./build-search-query";
+import type { SObjectSourceConfig } from "../types/search-config.types";
+import type { SourceRequest } from "../types/search-result.types";
+
+const accounts: SObjectSourceConfig = {
+	kind: "sobject",
+	key: "accounts",
+	label: "Accounts",
+	objectName: "Account",
+	displayFields: ["Name", { name: "Owner", subfields: ["Name"] }, { name: "Extra", raw: true }],
+	searchableFields: ["Name", "Owner.Name"],
+	filterBy: [{ field: "Type", label: "Type", type: "picklist" }],
+};
+
+const contacts: SObjectSourceConfig = {
+	kind: "sobject",
+	key: "contacts",
+	label: "Contacts",
+	objectName: "Contact",
+	idField: "ContactId",
+	displayFields: ["LastName"],
+	searchableFields: ["LastName"],
+};
+
+const request = (
+	source: SObjectSourceConfig,
+	overrides: Partial<SourceRequest> = {},
+): SourceRequest => ({
+	source,
+	q: "acme",
+	filters: [],
+	sort: null,
+	pageSize: 20,
+	afterCursor: undefined,
+	...overrides,
+});
+
+describe("buildSearchQuery", () => {
+	it("throws when no requests are provided", () => {
+		expect(() => buildSearchQuery([])).toThrow(
+			"buildSearchQuery requires at least one source request",
+		);
+	});
+
+	it("builds a single uiapi document with key-namespaced variables", () => {
+		const { document, variables } = buildSearchQuery([request(accounts)]);
+
+		expect(document).toContain("query Search(");
+		expect(document).toContain("uiapi {");
+		expect(document).toContain("accounts: Account(");
+		expect(document).toContain("$accounts_first: Int");
+		expect(document).toContain("$accounts_where: Account_Filter");
+		expect(document).toContain("$accounts_orderBy: Account_OrderBy");
+		expect(document).not.toContain("managed_content");
+		expect(variables).toMatchObject({
+			accounts_first: 20,
+			accounts_after: null,
+			accounts_orderBy: null,
+		});
+	});
+
+	it("renders string, nested and raw display fields plus the id field", () => {
+		const { document } = buildSearchQuery([request(accounts)]);
+
+		expect(document).toContain("Id");
+		expect(document).toContain("Name @optional { value displayValue }");
+		expect(document).toContain("Owner @optional {");
+		expect(document).toMatch(/^\s+Extra$/m);
+	});
+
+	it("batches multiple sources into one document and one variable map", () => {
+		const { document, variables } = buildSearchQuery([
+			request(accounts),
+			request(contacts, { afterCursor: "abc" }),
+		]);
+
+		expect(document.match(/query Search\(/g)).toHaveLength(1);
+		expect(document).toContain("accounts: Account(");
+		expect(document).toContain("contacts: Contact(");
+		expect(document).toContain("ContactId");
+		expect(variables).toHaveProperty("accounts_first");
+		expect(variables).toHaveProperty("contacts_first");
+		expect(variables["contacts_after"]).toBe("abc");
+	});
+
+	it("combines the global q clause with structured filters under and", () => {
+		const { variables } = buildSearchQuery([
+			request(accounts, {
+				filters: [{ field: "Type", label: "Type", type: "picklist", value: "Customer" }],
+			}),
+		]);
+
+		expect(variables["accounts_where"]).toEqual({
+			and: [
+				{
+					or: [{ Name: { like: "%acme%" } }, { Owner: { Name: { like: "%acme%" } } }],
+				},
+				{ Type: { eq: "Customer" } },
+			],
+		});
+	});
+
+	it("emits orderBy from the sort", () => {
+		const { variables } = buildSearchQuery([
+			request(accounts, { sort: { field: "Name", direction: "DESC" } }),
+		]);
+
+		expect(variables["accounts_orderBy"]).toEqual({ Name: { order: "DESC", nulls: "LAST" } });
+	});
+
+	it("honours whereTypeName / orderByTypeName overrides", () => {
+		const { document } = buildSearchQuery([
+			request({ ...accounts, whereTypeName: "Acct_Where", orderByTypeName: "Acct_Order" }),
+		]);
+
+		expect(document).toContain("$accounts_where: Acct_Where");
+		expect(document).toContain("$accounts_orderBy: Acct_Order");
+	});
+
+	it("rejects a source key that is not a valid GraphQL alias", () => {
+		expect(() => buildSearchQuery([request({ ...accounts, key: "bad-key" })])).toThrow(
+			/Invalid source key/,
+		);
+	});
+
+	it("rejects keys starting with __", () => {
+		expect(() => buildSearchQuery([request({ ...accounts, key: "__x" })])).toThrow(
+			/Invalid source key/,
+		);
+	});
+
+	it("rejects duplicate source keys", () => {
+		expect(() => buildSearchQuery([request(accounts), request(accounts)])).toThrow(
+			/Duplicate source key/,
+		);
+	});
+
+	it.each([
+		["objectName", { objectName: "Account) { x" }],
+		["idField", { idField: "Id }" }],
+		["whereTypeName", { whereTypeName: "A B" }],
+		["orderByTypeName", { orderByTypeName: "A-B" }],
+		["display field", { displayFields: ["Name } evil {"] }],
+		["nested subfield", { displayFields: [{ name: "Owner", subfields: ["Na me"] }] }],
+	])("rejects an unsafe %s", (_label, override) => {
+		expect(() =>
+			buildSearchQuery([request({ ...accounts, ...override } as SObjectSourceConfig)]),
+		).toThrow(/Invalid/);
+	});
+});

package/dist/force-app/main/default/uiBundles/feature-angular-search/src/app/features/search/query/build-search-query.ts

@@ -0,0 +1,95 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+/**
+ * Builds a single combined GraphQL document for search across every source.
+ *
+ * The builder is kind-agnostic: each source request is dispatched to its
+ * registered adapter for a `QueryFragmentContribution`:
+ *   - `placement: "uiapi.query"` fragments go inside the shared
+ *     `uiapi { query { ... } }` block.
+ *   - `placement: "root"` fragments go in as siblings of `uiapi`.
+ *   - every contribution's `variableDeclarations` are concatenated into the
+ *     `query Search(...)` header and its `variables` merged into one flat map.
+ */
+
+import { getAdapter } from "../adapters/registry";
+import type { SourceRequest } from "../types/search-result.types";
+
+export interface SearchQueryPayload {
+	document: string;
+	variables: Record<string, unknown>;
+}
+
+/**
+ * Builds the combined query document and a flat variables map by dispatching
+ * each source through its adapter and partitioning fragments by placement.
+ */
+export function buildSearchQuery(requests: SourceRequest[]): SearchQueryPayload {
+	if (requests.length === 0) {
+		throw new Error("buildSearchQuery requires at least one source request");
+	}
+
+	const keys = new Set<string>();
+	for (const { source } of requests) {
+		if (keys.has(source.key)) {
+			throw new Error(`Duplicate source key "${source.key}". Source keys must be unique.`);
+		}
+		keys.add(source.key);
+	}
+
+	const variableDeclarations: string[] = [];
+	const uiapiFragments: string[] = [];
+	const rootFragments: string[] = [];
+	const variables: Record<string, unknown> = {};
+
+	for (const request of requests) {
+		const contribution = getAdapter(request.source.kind).buildRequest(request);
+
+		// Concatenate declarations (may be empty for a given source) and merge
+		// values — an omitted declaration means the variable is never declared,
+		// so it is likewise never supplied.
+		variableDeclarations.push(...contribution.variableDeclarations);
+		Object.assign(variables, contribution.variables);
+
+		if (contribution.placement === "root") {
+			rootFragments.push(contribution.fragment);
+		} else {
+			uiapiFragments.push(contribution.fragment);
+		}
+	}
+
+	const parts: string[] = [`query Search(${variableDeclarations.join(", ")}) {`];
+
+	// The `uiapi { query { … } }` block holds every `uiapi.query`-placed fragment.
+	// Emit it only when at least one such fragment exists; an empty block is an
+	// invalid selection set.
+	if (uiapiFragments.length > 0) {
+		parts.push(`  uiapi {`);
+		parts.push(`    query {`);
+		parts.push(uiapiFragments.map((s) => indent(s, "      ")).join("\n"));
+		parts.push(`    }`);
+		parts.push(`  }`);
+	}
+
+	// Root-placement fragments are siblings of uiapi.
+	for (const fragment of rootFragments) {
+		parts.push(indent(fragment, "  "));
+	}
+
+	parts.push(`}`);
+
+	const document = parts.join("\n") + "\n";
+
+	return { document, variables };
+}
+
+function indent(s: string, prefix: string): string {
+	return s
+		.split("\n")
+		.map((line) => prefix + line)
+		.join("\n");
+}

package/dist/force-app/main/default/uiBundles/feature-angular-search/src/app/features/search/state/filter-mapping.ts

@@ -0,0 +1,48 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+import type { ActiveFilterValue, FilterFieldConfig, FilterFieldType } from "../types/filter.types";
+import type { FilterValue } from "../filters/filter-types";
+
+/**
+ * Maps between the state-agnostic filter-input contract ({@link FilterValue})
+ * and the canonical {@link ActiveFilterValue} the query builder consumes.
+ */
+
+/**
+ * The type an active filter carries. The date inputs always emit a min/max
+ * pair, so `date` / `datetime` configs are normalized to their range form;
+ * `buildFilter` produces the same clause for a single bound, and a range keeps
+ * both bounds (the single-bound form would silently drop `max`).
+ */
+export function activeTypeFor(type: FilterFieldType): FilterFieldType {
+	if (type === "date") return "daterange";
+	if (type === "datetime") return "datetimerange";
+	return type;
+}
+
+const has = (s: string | undefined): s is string => s !== undefined && s !== "";
+
+/** Active filter -> input value (`undefined` when the filter is inactive). */
+export function toFilterValue(active: ActiveFilterValue | undefined): FilterValue | undefined {
+	if (!active) return undefined;
+	return { value: active.value, min: active.min, max: active.max };
+}
+
+/** Input value -> active filter (`undefined` when the value carries no constraint). */
+export function toActiveFilter(
+	config: FilterFieldConfig,
+	value: FilterValue | undefined,
+): ActiveFilterValue | undefined {
+	if (!value || (!has(value.value) && !has(value.min) && !has(value.max))) return undefined;
+	return {
+		field: config.field,
+		label: config.label,
+		type: activeTypeFor(config.type),
+		value: value.value,
+		min: value.min,
+		max: value.max,
+	};
+}