@salesforce/ui-bundle-template-app-react-sample-b2e 11.20.0 → 11.22.0

package/dist/force-app/main/default/uiBundles/propertymanagementapp/src/features/search/utils/filterUtils.ts

@@ -0,0 +1,285 @@
+/**
+ * Filter primitives for search.
+ *
+ * Two responsibilities:
+ *   1. Build a GraphQL `where` clause from a list of active filter values.
+ *   2. Serialize/deserialize active filters to/from URLSearchParams under a
+ *      per-source namespace prefix (so multiple sources can coexist on one URL).
+ *
+ * The URL helpers are namespaced: each source declares its key, and filter
+ * params are written as `s.<key>.f.<field>=...`. Sort uses
+ * `s.<key>.sort=<field>&s.<key>.dir=ASC|DESC`. Page size and page index use
+ * `s.<key>.ps=<size>` and `s.<key>.page=<n>`.
+ *
+ * The global search term `q=...` is **not** scoped to a source — it's broadcast
+ * to every source's `searchableFields` by the query builder.
+ */
+
+import type { SortState } from "./sortUtils";
+
+export type FilterFieldType =
+	| "text"
+	| "picklist"
+	| "numeric"
+	| "boolean"
+	| "date"
+	| "daterange"
+	| "datetime"
+	| "datetimerange"
+	| "multipicklist";
+
+/**
+ * Which comparison UI a date/datetime filter exposes:
+ *   - `"range"`: a single Between control (two date inputs, lower–upper bound).
+ *   - `"comparison"`: an After / Before selector with one date input.
+ *   - `"both"`: a Between / After / Before selector that switches between the two.
+ *
+ * Applies only to the date-family `type`s (`date`, `daterange`, `datetime`,
+ * `datetimerange`); ignored for other field types. Defaults to `"comparison"`.
+ */
+export type DateFilterMode = "range" | "comparison" | "both";
+
+export type FilterFieldConfig<TFieldName extends string = string> = {
+	field: TFieldName;
+	label: string;
+	type: FilterFieldType;
+	placeholder?: string;
+	/** Required for picklist / multipicklist. */
+	options?: Array<{ value: string; label: string }>;
+	/** Date-family only — see {@link DateFilterMode}. Defaults to `"comparison"`. */
+	dateMode?: DateFilterMode;
+	helpText?: string;
+};
+
+export type ActiveFilterValue<TFieldName extends string = string> = {
+	field: TFieldName;
+	label: string;
+	type: FilterFieldType;
+	value?: string;
+	min?: string;
+	max?: string;
+};
+
+// ---------------------------------------------------------------------------
+// URL serialization (per-source namespace)
+// ---------------------------------------------------------------------------
+
+const SOURCE_PREFIX = "s.";
+const FILTER_INFIX = ".f.";
+const SORT_SUFFIX = ".sort";
+const DIR_SUFFIX = ".dir";
+const PAGE_SIZE_SUFFIX = ".ps";
+const PAGE_SUFFIX = ".page";
+
+/** Global search term key (not source-scoped). */
+export const GLOBAL_QUERY_KEY = "q";
+
+function filterKey(sourceKey: string, field: string, suffix?: string) {
+	return `${SOURCE_PREFIX}${sourceKey}${FILTER_INFIX}${field}${suffix ? `.${suffix}` : ""}`;
+}
+
+/**
+ * The source's own default sort / page size. When a source's current state
+ * matches these, the corresponding URL params are omitted so the query string
+ * only ever reflects an *explicit* user choice — resetting filters or returning
+ * a source to its defaults yields a clean URL instead of one littered with the
+ * defaults. The read path falls back to these same defaults when the params are
+ * absent, so the round-trip is lossless.
+ */
+export interface SourceParamDefaults {
+	sort?: SortState | null;
+	pageSize?: number;
+}
+
+function sortMatchesDefault(sort: SortState, defaultSort: SortState | null | undefined): boolean {
+	return (
+		!!defaultSort && sort.field === defaultSort.field && sort.direction === defaultSort.direction
+	);
+}
+
+export function writeSourceParams(
+	params: URLSearchParams,
+	sourceKey: string,
+	filters: ActiveFilterValue[],
+	sort: SortState | null,
+	pageSize?: number,
+	pageIndex?: number,
+	defaults?: SourceParamDefaults,
+): void {
+	for (const filter of filters) {
+		if (filter.value !== undefined && filter.value !== "") {
+			params.set(filterKey(sourceKey, filter.field), filter.value);
+		}
+		if (filter.min !== undefined && filter.min !== "") {
+			params.set(filterKey(sourceKey, filter.field, "min"), filter.min);
+		}
+		if (filter.max !== undefined && filter.max !== "") {
+			params.set(filterKey(sourceKey, filter.field, "max"), filter.max);
+		}
+	}
+	// Only serialize sort when it differs from the source default — otherwise
+	// the URL would carry the default the user never chose.
+	if (sort && !sortMatchesDefault(sort, defaults?.sort)) {
+		params.set(`${SOURCE_PREFIX}${sourceKey}${SORT_SUFFIX}`, sort.field);
+		params.set(`${SOURCE_PREFIX}${sourceKey}${DIR_SUFFIX}`, sort.direction);
+	}
+	if (pageSize !== undefined && pageSize !== defaults?.pageSize) {
+		params.set(`${SOURCE_PREFIX}${sourceKey}${PAGE_SIZE_SUFFIX}`, String(pageSize));
+	}
+	if (pageIndex !== undefined && pageIndex > 0) {
+		params.set(`${SOURCE_PREFIX}${sourceKey}${PAGE_SUFFIX}`, String(pageIndex + 1));
+	}
+}
+
+export interface ReadSourceParamsResult {
+	filters: ActiveFilterValue[];
+	sort: SortState | null;
+	pageSize: number | undefined;
+	pageIndex: number;
+}
+
+export function readSourceParams(
+	params: URLSearchParams,
+	sourceKey: string,
+	configs: FilterFieldConfig[],
+): ReadSourceParamsResult {
+	const filters: ActiveFilterValue[] = [];
+	for (const config of configs) {
+		const { field, label, type } = config;
+		const value = params.get(filterKey(sourceKey, field)) ?? undefined;
+		const min = params.get(filterKey(sourceKey, field, "min")) ?? undefined;
+		const max = params.get(filterKey(sourceKey, field, "max")) ?? undefined;
+
+		const hasValue = value !== undefined && value !== "";
+		const hasRange = (min !== undefined && min !== "") || (max !== undefined && max !== "");
+		if (hasValue || hasRange) {
+			filters.push({ field, label, type, value, min, max });
+		}
+	}
+
+	let sort: SortState | null = null;
+	const sortField = params.get(`${SOURCE_PREFIX}${sourceKey}${SORT_SUFFIX}`);
+	const sortDir = params.get(`${SOURCE_PREFIX}${sourceKey}${DIR_SUFFIX}`);
+	if (sortField) {
+		sort = { field: sortField, direction: sortDir === "DESC" ? "DESC" : "ASC" };
+	}
+
+	const pageSizeRaw = params.get(`${SOURCE_PREFIX}${sourceKey}${PAGE_SIZE_SUFFIX}`);
+	const pageSize = pageSizeRaw ? parseInt(pageSizeRaw, 10) : undefined;
+	const pageRaw = params.get(`${SOURCE_PREFIX}${sourceKey}${PAGE_SUFFIX}`);
+	const page = pageRaw ? parseInt(pageRaw, 10) : 1;
+	const pageIndex = !isNaN(page) && page > 1 ? page - 1 : 0;
+
+	return {
+		filters,
+		sort,
+		pageSize: pageSize && !isNaN(pageSize) ? pageSize : undefined,
+		pageIndex,
+	};
+}
+
+// ---------------------------------------------------------------------------
+// GraphQL filter building
+// ---------------------------------------------------------------------------
+
+/**
+ * Combines active filter values into a GraphQL `where` clause for one source.
+ * Returns `undefined` when no constraints are active.
+ */
+export function buildFilter(filters: ActiveFilterValue[], configs: FilterFieldConfig[]): unknown {
+	const configMap = new Map(configs.map((c) => [c.field, c]));
+	const clauses: unknown[] = [];
+	for (const filter of filters) {
+		const clause = buildSingleFilter(filter, configMap.get(filter.field));
+		if (clause) clauses.push(clause);
+	}
+	if (clauses.length === 0) return undefined;
+	if (clauses.length === 1) return clauses[0];
+	return { and: clauses };
+}
+
+function toStartOfDay(d: string) {
+	return `${d}T00:00:00.000Z`;
+}
+function toEndOfDay(d: string) {
+	return `${d}T23:59:59.999Z`;
+}
+
+function buildSingleFilter(filter: ActiveFilterValue, _config?: FilterFieldConfig): unknown {
+	const { field, type, value, min, max } = filter;
+	switch (type) {
+		case "text": {
+			if (!value) return null;
+			return { [field]: { like: `%${value}%` } };
+		}
+		case "picklist": {
+			if (!value) return null;
+			return { [field]: { eq: value } };
+		}
+		case "numeric": {
+			if (!min && !max) return null;
+			const ops: Record<string, number> = {};
+			if (min) ops.gte = Number(min);
+			if (max) ops.lte = Number(max);
+			return { [field]: ops };
+		}
+		case "boolean": {
+			if (value === undefined || value === "") return null;
+			return { [field]: { eq: value === "true" } };
+		}
+		case "multipicklist": {
+			if (!value) return null;
+			const values = value.split(",").filter(Boolean);
+			if (values.length === 0) return null;
+			if (values.length === 1) return { [field]: { eq: values[0] } };
+			return { [field]: { in: values } };
+		}
+		case "date": {
+			if (!min && !max) return null;
+			const op = min ? "gte" : "lte";
+			const dateStr = min ?? max;
+			return { [field]: { [op]: { value: dateStr } } };
+		}
+		case "daterange": {
+			if (!min && !max) return null;
+			const clauses: unknown[] = [];
+			if (min) clauses.push({ [field]: { gte: { value: min } } });
+			if (max) clauses.push({ [field]: { lte: { value: max } } });
+			return clauses.length === 1 ? clauses[0] : { and: clauses };
+		}
+		case "datetime": {
+			if (!min && !max) return null;
+			const op = min ? "gte" : "lte";
+			const dateStr = min ?? max;
+			const isoStr = op === "gte" ? toStartOfDay(dateStr!) : toEndOfDay(dateStr!);
+			return { [field]: { [op]: { value: isoStr } } };
+		}
+		case "datetimerange": {
+			if (!min && !max) return null;
+			const clauses: unknown[] = [];
+			if (min) clauses.push({ [field]: { gte: { value: toStartOfDay(min) } } });
+			if (max) clauses.push({ [field]: { lte: { value: toEndOfDay(max) } } });
+			return clauses.length === 1 ? clauses[0] : { and: clauses };
+		}
+		default:
+			return null;
+	}
+}
+
+/**
+ * Builds a global-q `or` clause across the source's searchable fields.
+ * Returns `undefined` when q is empty or the source has no searchable fields.
+ */
+export function buildGlobalQueryClause(q: string, searchableFields: string[]): unknown {
+	const trimmed = q.trim();
+	if (!trimmed || searchableFields.length === 0) return undefined;
+	const clauses = searchableFields.map((path) => {
+		const parts = path.split(".");
+		let clause: Record<string, unknown> = { like: `%${trimmed}%` };
+		for (let i = parts.length - 1; i >= 0; i--) {
+			clause = { [parts[i]]: clause };
+		}
+		return clause;
+	});
+	return clauses.length === 1 ? clauses[0] : { or: clauses };
+}

package/dist/force-app/main/default/uiBundles/propertymanagementapp/src/features/search/utils/sortUtils.ts

@@ -0,0 +1,34 @@
+/**
+ * Sort state and order-by builder for search.
+ *
+ * The order-by output shape matches the Salesforce uiapi GraphQL convention:
+ *   { [field]: { order: ASC|DESC, nulls: LAST } }
+ *
+ * The constants are stringly-typed here (rather than imported from codegen)
+ * because search builds its query at runtime and isn't tied to a
+ * specific generated schema.
+ */
+
+export type SortFieldConfig<TFieldName extends string = string> = {
+	field: TFieldName;
+	label: string;
+};
+
+export type SortState<TFieldName extends string = string> = {
+	field: TFieldName;
+	direction: "ASC" | "DESC";
+};
+
+const ORDER_ASC = "ASC";
+const ORDER_DESC = "DESC";
+const NULLS_LAST = "LAST";
+
+export function buildOrderBy(sort: SortState | null): unknown {
+	if (!sort) return undefined;
+	return {
+		[sort.field]: {
+			order: sort.direction === "ASC" ? ORDER_ASC : ORDER_DESC,
+			nulls: NULLS_LAST,
+		},
+	};
+}

package/dist/force-app/main/default/uiBundles/propertymanagementapp/src/lib/constants.ts

@@ -2,34 +2,26 @@
  * Application-wide constants.
  */
 
-import type { PaginationConfig } from "../features/object-search/hooks/useObjectSearchParams";
+const MAINTENANCE_WORKER_OBJECT_API_NAME = "Maintenance_Worker__c" as const;
 
-export const PAGE_SIZE_LIST = 12;
-export const DASHBOARD_MAINTENANCE_LIMIT = 5;
+const FALLBACK_LABEL_PROPERTIES_PLURAL = "Properties";
+const FALLBACK_LABEL_MAINTENANCE_PLURAL = "Maintenance Requests";
+const FALLBACK_LABEL_MAINTENANCE_WORKERS_PLURAL = "Maintenance Workers";
+const FALLBACK_LABEL_APPLICATIONS_PLURAL = "Applications";
 
-export const PROPERTY_FILTER_EXCLUDED_FIELD_PATHS = new Set([
-	"CreatedDate",
-	"Hero_Image__c",
-	"Year_Built__c",
-	"Available_Date__c",
-]);
-
-export const MAINTENANCE_WORKER_FILTER_EXCLUDED_FIELD_PATHS = new Set<string>([]);
-export const MAINTENANCE_FILTER_EXCLUDED_FIELD_PATHS = new Set(["Scheduled__c"]);
-export const APPLICATION_FILTER_EXCLUDED_FIELD_PATHS = new Set<string>([]);
-
-export const MAINTENANCE_WORKER_OBJECT_API_NAME = "Maintenance_Worker__c" as const;
-
-export const FALLBACK_LABEL_PROPERTIES_PLURAL = "Properties";
-export const FALLBACK_LABEL_MAINTENANCE_PLURAL = "Maintenance Requests";
-export const FALLBACK_LABEL_MAINTENANCE_WORKERS_PLURAL = "Maintenance Workers";
-export const FALLBACK_LABEL_APPLICATIONS_PLURAL = "Applications";
-
-export const PROPERTY_OBJECT_API_NAME = "Property__c" as const;
-export const MAINTENANCE_OBJECT_API_NAME = "Maintenance_Request__c" as const;
-export const APPLICATION_OBJECT_API_NAME = "Application__c" as const;
+/**
+ * Sentinel value for the "search across everything" option in the dashboard
+ * search dropdown. Selecting it routes to the unified `/search` page rather
+ * than a single-object list page.
+ */
+export const ALL_SEARCH_OBJECT_VALUE = "All" as const;
 
 export const SEARCHABLE_OBJECTS = [
+	{
+		objectApiName: ALL_SEARCH_OBJECT_VALUE,
+		path: "/search",
+		fallbackLabelPlural: "All",
+	},
 	{
 		objectApiName: "Property__c" as const,
 		path: "/properties",
@@ -53,8 +45,3 @@ export const SEARCHABLE_OBJECTS = [
 ] as const;
 
 export type SearchableObjectConfig = (typeof SEARCHABLE_OBJECTS)[number];
-
-export const PAGINATION_CONFIG: PaginationConfig = {
-	defaultPageSize: 6,
-	validPageSizes: [6, 12, 24, 48],
-};

package/dist/force-app/main/default/uiBundles/propertymanagementapp/src/lib/routeConfig.ts

@@ -4,6 +4,7 @@
  */
 export const PATHS = {
 	HOME: "/",
+	SEARCH: "/search",
 	PROPERTIES: "/properties",
 	MAINTENANCE_REQUESTS: "/maintenance/requests",
 	MAINTENANCE_WORKERS: "/maintenance/workers",

package/dist/force-app/main/default/uiBundles/propertymanagementapp/src/lib/searchConfig.ts

@@ -0,0 +1,190 @@
+/**
+ * Property-management search configuration for feature-react-search.
+ *
+ * The search feature builds its GraphQL queries at runtime from this config, so
+ * the app no longer ships per-object `.graphql` search documents or
+ * `searchObjects()` services. One `SearchConfig` describes all four searchable
+ * objects; `<UnifiedSearch>` consumes it for both the unified `/search` page and
+ * each single-object page (via `restrictTo`).
+ *
+ * `displayFields` must cover every field the result cards and detail modals read
+ * — see the matching `*SearchNode` types in `src/api/**`. Relationships that
+ * require arguments (e.g. `ContentDocumentLinks(first: 1)` thumbnails or the
+ * worker's open-request `totalCount`) cannot be expressed here and are
+ * intentionally omitted; the cards degrade gracefully when they are absent.
+ */
+
+import type { SearchConfig } from "../features/search";
+
+/** Stable source keys — used as GraphQL aliases, URL namespaces, and result-map keys. */
+export const SOURCE_KEYS = {
+	PROPERTIES: "properties",
+	MAINTENANCE: "maintenance",
+	WORKERS: "workers",
+	APPLICATIONS: "applications",
+} as const;
+
+export type SourceKey = (typeof SOURCE_KEYS)[keyof typeof SOURCE_KEYS];
+
+/** Page-size options shared by every source (cards lay out 3-up). */
+export const SEARCH_PAGE_SIZE = 6;
+export const SEARCH_PAGE_SIZE_OPTIONS = [6, 12, 24, 48];
+
+export const searchConfig: SearchConfig = {
+	// One global pagination config — the single source of truth for the whole
+	// search experience. `merged` mode windows the cumulative result set into
+	// fixed pages of `pageSize`, and `proportional` spreads each object type by
+	// its result count so larger sources appear more often. These settings apply
+	// to every object type, in every scope — the unified `/search` page, when the
+	// dropdown narrows to one source, and single-object pages (via `restrictTo`).
+	pagination: {
+		mode: "merged",
+		mergeOrder: "proportional",
+		pageSize: SEARCH_PAGE_SIZE,
+		pageSizeOptions: SEARCH_PAGE_SIZE_OPTIONS,
+	},
+	sources: [
+		{
+			kind: "sobject",
+			key: SOURCE_KEYS.PROPERTIES,
+			objectName: "Property__c",
+			label: "Properties",
+			labelSingular: "Property",
+			searchableFields: ["Name", "Address__c"],
+			displayFields: [
+				"Name",
+				"Address__c",
+				"Status__c",
+				"Type__c",
+				"Monthly_Rent__c",
+				"Bedrooms__c",
+				"Bathrooms__c",
+				"Description__c",
+				"Hero_Image__c",
+				"Sq_Ft__c",
+				"Year_Built__c",
+				"Deposit__c",
+				"Parking__c",
+				"Pet_Friendly__c",
+				"Available_Date__c",
+				"Lease_Term__c",
+				"Features__c",
+				"Utilities__c",
+				"Tour_URL__c",
+				"CreatedDate",
+			],
+			filterBy: [
+				{ field: "Status__c", label: "Status", type: "multipicklist" },
+				{ field: "Type__c", label: "Type", type: "multipicklist" },
+				{ field: "Monthly_Rent__c", label: "Monthly Rent", type: "numeric" },
+				{ field: "Bedrooms__c", label: "Bedrooms", type: "numeric" },
+			],
+			sortBy: [
+				{ field: "Name", label: "Name" },
+				{ field: "Monthly_Rent__c", label: "Monthly Rent" },
+				{ field: "Status__c", label: "Status" },
+				{ field: "CreatedDate", label: "Created Date" },
+			],
+		},
+		{
+			kind: "sobject",
+			key: SOURCE_KEYS.MAINTENANCE,
+			objectName: "Maintenance_Request__c",
+			label: "Maintenance Requests",
+			labelSingular: "Maintenance Request",
+			searchableFields: [
+				"Name",
+				"User__r.Name",
+				"Property__r.Address__c",
+				"Assigned_Worker__r.Name",
+			],
+			displayFields: [
+				"Name",
+				"Description__c",
+				"Type__c",
+				"Priority__c",
+				"Status__c",
+				"Scheduled__c",
+				{ name: "Property__r", subfields: ["Address__c", "Name"] },
+				{ name: "User__r", subfields: ["Name"] },
+				{ name: "Assigned_Worker__r", subfields: ["Name"] },
+			],
+			filterBy: [
+				{ field: "Status__c", label: "Status", type: "multipicklist" },
+				{ field: "Type__c", label: "Type", type: "multipicklist" },
+				{ field: "Priority__c", label: "Priority", type: "multipicklist" },
+				{ field: "Scheduled__c", label: "Scheduled", type: "datetime" },
+			],
+			sortBy: [
+				{ field: "Name", label: "Subject" },
+				{ field: "Status__c", label: "Status" },
+				{ field: "Priority__c", label: "Priority" },
+				{ field: "Scheduled__c", label: "Scheduled" },
+				{ field: "CreatedDate", label: "Created Date" },
+			],
+			defaultSort: { field: "CreatedDate", direction: "DESC" },
+		},
+		{
+			kind: "sobject",
+			key: SOURCE_KEYS.WORKERS,
+			objectName: "Maintenance_Worker__c",
+			label: "Maintenance Workers",
+			labelSingular: "Maintenance Worker",
+			searchableFields: ["Name", "Phone__c"],
+			displayFields: [
+				"Name",
+				"Type__c",
+				"Employment_Type__c",
+				"Phone__c",
+				"Location__c",
+				"IsActive__c",
+				"Rating__c",
+				"Hourly_Rate__c",
+				"CreatedDate",
+			],
+			filterBy: [
+				{ field: "Employment_Type__c", label: "Employment Type", type: "multipicklist" },
+				{ field: "Location__c", label: "Location", type: "text", placeholder: "Location" },
+				{ field: "Hourly_Rate__c", label: "Hourly Rate", type: "numeric" },
+				{ field: "CreatedDate", label: "Created Date", type: "datetime" },
+			],
+			sortBy: [
+				{ field: "Name", label: "Name" },
+				{ field: "Employment_Type__c", label: "Employment Type" },
+				{ field: "Hourly_Rate__c", label: "Hourly Rate" },
+				{ field: "Rating__c", label: "Rating" },
+				{ field: "CreatedDate", label: "Created Date" },
+			],
+		},
+		{
+			kind: "sobject",
+			key: SOURCE_KEYS.APPLICATIONS,
+			objectName: "Application__c",
+			label: "Applications",
+			labelSingular: "Application",
+			searchableFields: ["Name", "User__r.Name", "Property__r.Address__c"],
+			displayFields: [
+				"Name",
+				"Status__c",
+				"Start_Date__c",
+				"Employment__c",
+				"References__c",
+				{ name: "Property__r", subfields: ["Name", "Address__c"] },
+				{ name: "User__r", subfields: ["Name"] },
+				"CreatedDate",
+			],
+			filterBy: [
+				{ field: "Status__c", label: "Status", type: "multipicklist" },
+				{ field: "Start_Date__c", label: "Start Date", type: "date" },
+				{ field: "CreatedDate", label: "Created Date", type: "datetime" },
+			],
+			sortBy: [
+				{ field: "Name", label: "Application" },
+				{ field: "Status__c", label: "Status" },
+				{ field: "Start_Date__c", label: "Start Date" },
+				{ field: "CreatedDate", label: "Created Date" },
+			],
+			defaultSort: { field: "CreatedDate", direction: "DESC" },
+		},
+	],
+};