@salesforce/webapp-template-app-react-sample-b2e-experimental 1.72.0 → 1.73.1

package/dist/force-app/main/default/webapplications/appreactsampleb2e/src/features/global-search/utils/linkUtils.ts

@@ -0,0 +1,14 @@
+/**
+ * Shared allowlist for link protocols (e.g. for FormattedUrl, and future mailto/tel if rendered as links).
+ * Centralizes protocol checks so new link types can be added in one place.
+ */
+export const ALLOWED_LINK_PROTOCOLS = ["http:", "https:"] as const;
+
+export function isAllowedLinkUrl(value: string): boolean {
+	try {
+		const u = new URL(value);
+		return (ALLOWED_LINK_PROTOCOLS as readonly string[]).includes(u.protocol);
+	} catch {
+		return false;
+	}
+}

package/dist/force-app/main/default/webapplications/appreactsampleb2e/src/features/global-search/utils/paginationUtils.ts

@@ -0,0 +1,49 @@
+/**
+ * Pagination Utilities
+ *
+ * Utility functions for pagination-related operations including page size validation.
+ */
+
+/**
+ * Default page size options for pagination
+ */
+export const PAGE_SIZE_OPTIONS = [
+	{ value: "10", label: "10" },
+	{ value: "20", label: "20" },
+	{ value: "50", label: "50" },
+] as const;
+
+/**
+ * Valid page size values extracted from PAGE_SIZE_OPTIONS
+ */
+export const VALID_PAGE_SIZES = PAGE_SIZE_OPTIONS.map((opt) => parseInt(opt.value, 10));
+
+/**
+ * Validates that a page size is one of the allowed options
+ * @param size - The page size to validate
+ * @returns true if valid, false otherwise
+ *
+ * @example
+ * ```tsx
+ * if (isValidPageSize(userInput)) {
+ *   setPageSize(userInput);
+ * }
+ * ```
+ */
+export function isValidPageSize(size: number): boolean {
+	return VALID_PAGE_SIZES.includes(size);
+}
+
+/**
+ * Gets a valid page size, defaulting to the first option if invalid
+ * @param size - The page size to validate
+ * @returns A valid page size
+ *
+ * @example
+ * ```tsx
+ * const safePageSize = getValidPageSize(userInput); // Returns valid size or default
+ * ```
+ */
+export function getValidPageSize(size: number): number {
+	return isValidPageSize(size) ? size : VALID_PAGE_SIZES[0];
+}

package/dist/force-app/main/default/webapplications/appreactsampleb2e/src/features/global-search/utils/recordUtils.ts

@@ -0,0 +1,159 @@
+/**
+ * Record utilities: layout-derived fields for GraphQL fetch, safe keys, ID validation.
+ *
+ * calculateFieldsToFetch: from layout + object metadata → field names and relation map;
+ * used by objectDetailService and list to build columns. findIdFieldForRelationship ensures
+ * Id + relationship name are both requested for reference display.
+ *
+ * @module utils/recordUtils
+ */
+
+import type { ObjectInfoResult } from "../types/objectInfo/objectInfo";
+import type {
+	LayoutResponse,
+	LayoutRow,
+	LayoutSection,
+	LayoutItem,
+	LayoutComponent,
+} from "../types/recordDetail/recordDetail";
+
+/**
+ * Find the Id field (reference foreign key) whose relationshipName matches the given name,
+ * so we can request both Id and relationship in the record query for display.
+ */
+function findIdFieldForRelationship(
+	metadata: ObjectInfoResult,
+	relationshipName: string,
+): string | null {
+	if (!metadata.fields || !relationshipName) return null;
+	for (const [apiName, field] of Object.entries(metadata.fields)) {
+		const isReference = field.dataType != null && field.dataType.toLowerCase() === "reference";
+		if (field.relationshipName === relationshipName && (isReference || apiName.endsWith("Id"))) {
+			return apiName;
+		}
+	}
+	return null;
+}
+
+const getFetchableFieldsFromLayoutItem = function (
+	metadata: ObjectInfoResult,
+	layoutItem: LayoutItem,
+	relationFieldMap: Record<string, string>,
+) {
+	const fields: Record<string, string> = {};
+	layoutItem.layoutComponents.forEach((comp: LayoutComponent) => {
+		// check if this is a field to add
+		if (!comp.apiName || comp.componentType !== "Field") {
+			return;
+		}
+
+		// add field: fieldType
+		const fieldMetadata = metadata.fields[comp.apiName];
+		fields[comp.apiName] = fieldMetadata ? fieldMetadata.dataType : "";
+
+		// add relatedField if one exists (Id field -> add relationship name so we request Owner.Name)
+		if (comp.apiName in metadata.fields) {
+			const relationshipName = fieldMetadata?.relationshipName;
+			if (relationshipName) {
+				fields[relationshipName] = fieldMetadata.dataType;
+
+				relationFieldMap[comp.apiName] = relationshipName;
+			}
+		} else {
+			// layout component is relationship name (e.g. Owner); ensure we also request the Id
+			// so buildSelectionTree sees both OwnerId and Owner and requests Owner { Name { value } }
+			const idField = findIdFieldForRelationship(metadata, comp.apiName);
+			if (idField) {
+				const idMeta = metadata.fields[idField];
+				fields[idField] = idMeta ? idMeta.dataType : "";
+				relationFieldMap[idField] = comp.apiName;
+			}
+		}
+	});
+	return fields;
+};
+
+const getFetchableFieldsFromLayoutRow = function (
+	metadata: ObjectInfoResult,
+	layoutRow: LayoutRow,
+	relationFieldMap: Record<string, string>,
+) {
+	let fieldsFromRow: Record<string, string> = {};
+	layoutRow.layoutItems.forEach((item: LayoutItem) => {
+		Object.assign(
+			fieldsFromRow,
+			getFetchableFieldsFromLayoutItem(metadata, item, relationFieldMap),
+		);
+	});
+	return fieldsFromRow;
+};
+
+const getFetchableFieldsFromSection = function (
+	metadata: ObjectInfoResult,
+	section: LayoutSection,
+	relationFieldMap: Record<string, string>,
+) {
+	let fieldsFromSection: Record<string, string> = {};
+	section.layoutRows.forEach((row: LayoutRow) => {
+		Object.assign(
+			fieldsFromSection,
+			getFetchableFieldsFromLayoutRow(metadata, row, relationFieldMap),
+		);
+	});
+	return fieldsFromSection;
+};
+
+const getFetchableFieldsFromLayout = function (
+	metadata: ObjectInfoResult,
+	layout: LayoutResponse,
+	relationFieldMap: Record<string, string>,
+) {
+	let fieldsFromLayout: Record<string, string> = {};
+	layout.sections.forEach((section) => {
+		Object.assign(
+			fieldsFromLayout,
+			getFetchableFieldsFromSection(metadata, section, relationFieldMap),
+		);
+	});
+	return fieldsFromLayout;
+};
+
+/**
+ * Returns field API names to request for records from layout + object metadata.
+ * Includes both Id and relationship name for reference fields so GraphQL can fetch display value.
+ *
+ * @param metadata - Object info (fields with dataType, relationshipName).
+ * @param layout - Layout response (sections, layoutItems, layoutComponents).
+ * @param shouldPrefixedWithEntityName - If true, prefix names with object (e.g. Account.Name).
+ * @returns [fieldNames, fieldTypes, relationFieldMap] for buildSelectionTree / optionalFields.
+ */
+export const calculateFieldsToFetch = function (
+	metadata: ObjectInfoResult,
+	layout: LayoutResponse,
+	shouldPrefixedWithEntityName: boolean,
+): [string[], string[], Record<string, string>] {
+	const relationFieldMap: Record<string, string> = {};
+	// populating fields to query for layout
+	const fields = getFetchableFieldsFromLayout(metadata, layout, relationFieldMap);
+	let fieldsToFetch = Object.keys(fields);
+	if (shouldPrefixedWithEntityName) {
+		fieldsToFetch = fieldsToFetch.map((field) => `${metadata.apiName}.${field}`);
+	}
+	// populate field types for o11y logging
+	const fieldTypes = Object.values(fields).filter((fieldType) => fieldType !== "");
+	return [fieldsToFetch, fieldTypes, relationFieldMap];
+};
+/** Type guard: true if id is a non-empty string matching 15- or 18-char Salesforce ID format. */
+export function isValidSalesforceId(id: string | null | undefined): id is string {
+	if (!id || typeof id !== "string") return false;
+	return /^[a-zA-Z0-9]{15}$|^[a-zA-Z0-9]{18}$/.test(id);
+}
+
+/** Safe React key from record id or fallback to prefix-index. */
+export function getSafeKey(
+	recordId: string | null | undefined,
+	index: number,
+	prefix: string = "result",
+): string {
+	return isValidSalesforceId(recordId) ? recordId : `${prefix}-${index}`;
+}

package/dist/force-app/main/default/webapplications/appreactsampleb2e/src/features/global-search/utils/sanitizationUtils.ts

@@ -0,0 +1,49 @@
+/**
+ * Sanitization Utilities
+ *
+ * Utility functions for sanitizing user input to prevent injection attacks.
+ * These utilities provide basic sanitization for filter values.
+ */
+
+/**
+ * Sanitizes a string value by removing potentially dangerous characters
+ * and trimming whitespace.
+ *
+ * This is a basic sanitization - for production, consider using a library like DOMPurify for more
+ * comprehensive sanitization.
+ * Also, note this is NOT an end-to-end security control.
+ * Client-side sanitization can be bypassed by any attacker using `curl` or Postman.
+ * To prevent injection attacks (SOSL Injection, XSS):
+ * 1. The BACKEND (Salesforce API) handles SOSL injection if parameters are passed correctly.
+ * 2. React handles XSS automatically when rendering variables in JSX (e.g., <div>{value}</div>).
+ * Do not rely on this function for end-to-end security enforcement.
+ *
+ * @param value - The string value to sanitize
+ * @returns Sanitized string value
+ *
+ * @remarks
+ * - Removes control characters (except newlines, tabs, carriage returns)
+ * - Trims leading/trailing whitespace
+ * - Limits length to prevent DoS attacks (default: 1000 characters)
+ * - Preserves alphanumeric, spaces, and common punctuation
+ *
+ * @example
+ * ```tsx
+ * const sanitized = sanitizeFilterValue(userInput);
+ * ```
+ */
+export function sanitizeFilterValue(value: string, maxLength: number = 1000): string {
+	if (typeof value !== "string") {
+		return "";
+	}
+
+	let sanitized = value.trim();
+
+	if (sanitized.length > maxLength) {
+		sanitized = sanitized.substring(0, maxLength);
+	}
+
+	sanitized = sanitized.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "");
+
+	return sanitized;
+}

package/dist/force-app/main/default/webapplications/appreactsampleb2e/src/hooks/useAccumulatedListPages.ts

@@ -0,0 +1,29 @@
+import { useState, useRef, useEffect, type Dispatch, type SetStateAction } from "react";
+
+/**
+ * Accumulates list pages when the GraphQL hook returns one page at a time.
+ * When loading goes from true to false: if afterCursor is null, replaces the list;
+ * otherwise appends (load more). Caller must reset accumulated when search/filters/sort change.
+ */
+export function useAccumulatedListPages<T>(
+	edges: Array<{ node?: unknown }>,
+	loading: boolean,
+	afterCursor: string | null,
+	mapNode: (node: unknown) => T,
+): [T[], Dispatch<SetStateAction<T[]>>] {
+	const [accumulated, setAccumulated] = useState<T[]>([]);
+	const prevLoadingRef = useRef(loading);
+
+	useEffect(() => {
+		const isFirstPage = afterCursor === null;
+		const justFinishedLoading = prevLoadingRef.current && !loading;
+		if (justFinishedLoading) {
+			const list = edges.map((e) => mapNode(e.node));
+			if (isFirstPage) setAccumulated(list);
+			else setAccumulated((prev) => [...prev, ...list]);
+		}
+		prevLoadingRef.current = loading;
+	}, [loading, edges, afterCursor, mapNode]);
+
+	return [accumulated, setAccumulated];
+}

package/dist/force-app/main/default/webapplications/appreactsampleb2e/src/hooks/useListPage.ts

@@ -0,0 +1,167 @@
+import { useEffect, useState, useRef, useMemo, useCallback } from "react";
+import { useSearchParams } from "react-router";
+import {
+	useObjectListMetadata,
+	useRecordListGraphQL,
+	type FilterCriteria,
+} from "@salesforce/webapp-template-feature-react-global-search-experimental";
+import { PAGE_SIZE_LIST } from "../lib/constants.js";
+import {
+	buildFilterCriteriaFromFormValues,
+	getDefaultFilterFormValues,
+	getApplicableFilters,
+} from "../lib/filterUtils.js";
+import { useAccumulatedListPages } from "./useAccumulatedListPages.js";
+import type { ListPageConfig } from "../lib/listPageConfig.js";
+
+/** Picklist option shape from useObjectListMetadata (label/value). */
+export interface PicklistOption {
+	label?: string;
+	value: string;
+}
+
+export interface UseListPageResult<T> {
+	filters: ReturnType<typeof getApplicableFilters>;
+	picklistValues: Record<string, PicklistOption[]>;
+	formValues: Record<string, string>;
+	onFormValueChange: (key: string, value: string) => void;
+	onApplyFilters: () => void;
+	onResetFilters: () => void;
+	filterError: string | null;
+	loading: boolean;
+	error: string | null;
+	items: T[];
+	canLoadMore: boolean;
+	onLoadMore: () => void;
+	loadMoreLoading: boolean;
+	sortBy?: string;
+	onSortChange?: (sortBy: string) => void;
+}
+
+/**
+ * Shared hook for list pages with API-driven filters and GraphQL data.
+ * Uses useObjectListMetadata and useRecordListGraphQL; search comes from URL ?q=.
+ * Pass the returned props to ListPageWithFilters and render your table/list as children.
+ */
+export function useListPage<T>(config: ListPageConfig<T>): UseListPageResult<T> {
+	const [searchParams] = useSearchParams();
+	const searchQuery = searchParams.get("q") ?? "";
+
+	const [afterCursor, setAfterCursor] = useState<string | null>(null);
+	const [appliedFilters, setAppliedFilters] = useState<FilterCriteria[]>([]);
+	const [filterFormValues, setFilterFormValues] = useState<Record<string, string>>({});
+	const [filterError, setFilterError] = useState<string | null>(null);
+	const hasInitializedFiltersRef = useRef(false);
+	const [sortBy, setSortBy] = useState(config.defaultSort);
+
+	const listMeta = useObjectListMetadata(config.objectApiName);
+	const columns = useMemo(() => config.getColumns(listMeta.columns), [listMeta.columns, config]);
+	const filters = useMemo(
+		() => getApplicableFilters(listMeta.filters ?? [], config.filterExcludedFieldPaths),
+		[listMeta.filters, config.filterExcludedFieldPaths],
+	);
+	const picklistValues = listMeta.picklistValues ?? {};
+
+	const effectiveSort = config.sortable ? sortBy : config.defaultSort;
+
+	const {
+		edges,
+		pageInfo,
+		loading: resultsLoading,
+		error: resultsError,
+	} = useRecordListGraphQL({
+		objectApiName: config.objectApiName,
+		columns,
+		columnsLoading: listMeta.loading,
+		columnsError: listMeta.error,
+		first: PAGE_SIZE_LIST,
+		after: afterCursor,
+		searchQuery: searchQuery.trim() || undefined,
+		sortBy: effectiveSort,
+		filters: appliedFilters,
+	});
+
+	const mapNode = useCallback((node: unknown) => config.nodeToItem(node), [config]);
+
+	const [accumulated, setAccumulated] = useAccumulatedListPages(
+		edges,
+		resultsLoading,
+		afterCursor,
+		mapNode,
+	);
+
+	useEffect(() => {
+		if (filters.length === 0) return;
+		if (!hasInitializedFiltersRef.current) {
+			hasInitializedFiltersRef.current = true;
+			setFilterFormValues(getDefaultFilterFormValues(filters));
+		}
+	}, [filters]);
+
+	useEffect(() => {
+		setAfterCursor(null);
+		setAccumulated([]);
+	}, [searchQuery, appliedFilters, effectiveSort, setAccumulated]);
+
+	const loading = listMeta.loading || resultsLoading;
+	const error = listMeta.error ?? resultsError ?? null;
+	const hasNextPage = Boolean(pageInfo?.hasNextPage);
+	const endCursor = pageInfo?.endCursor ?? null;
+
+	const onLoadMore = useCallback(() => {
+		if (endCursor && !searchQuery.trim()) setAfterCursor(endCursor);
+	}, [endCursor, searchQuery]);
+
+	const onApplyFilters = useCallback(() => {
+		setFilterError(null);
+		const result = buildFilterCriteriaFromFormValues(
+			config.objectApiName,
+			filters,
+			filterFormValues,
+		);
+		if (result.rangeError) {
+			setFilterError(result.rangeError);
+			return;
+		}
+		setAppliedFilters(result.criteria);
+		setAfterCursor(null);
+	}, [config.objectApiName, filters, filterFormValues]);
+
+	const onResetFilters = useCallback(() => {
+		setFilterFormValues(getDefaultFilterFormValues(filters));
+		setAppliedFilters([]);
+		setAfterCursor(null);
+		setFilterError(null);
+	}, [filters]);
+
+	const onFormValueChange = useCallback((key: string, value: string) => {
+		setFilterFormValues((prev) => ({ ...prev, [key]: value }));
+		setFilterError(null);
+	}, []);
+
+	const onSortChange = useCallback((newSortBy: string) => {
+		setSortBy(newSortBy);
+		setAfterCursor(null);
+	}, []);
+
+	const result: UseListPageResult<T> = {
+		filters,
+		picklistValues: picklistValues as Record<string, PicklistOption[]>,
+		formValues: filterFormValues,
+		onFormValueChange,
+		onApplyFilters,
+		onResetFilters,
+		filterError,
+		loading,
+		error,
+		items: accumulated,
+		canLoadMore: hasNextPage && !searchQuery.trim(),
+		onLoadMore,
+		loadMoreLoading: resultsLoading,
+	};
+	if (config.sortable) {
+		result.sortBy = sortBy;
+		result.onSortChange = onSortChange;
+	}
+	return result;
+}

package/dist/force-app/main/default/webapplications/appreactsampleb2e/src/index.ts

@@ -1,6 +1,10 @@
 /**
- * feature-react-agentforce-conversation-client – ACC Conversation Client
+ * Package entry for @salesforce/webapp-template-feature-react-global-search-experimental.
+ * Exports only API, hooks, utils, types, and constants so that consuming apps do not
+ * pull in the feature's UI (routes, __inherit__ components) which depend on @radix-ui.
  */
-
-export { AgentforceConversationClient } from "./components/AgentforceConversationClient";
-export type { AgentforceConversationClientProps, ResolvedEmbedOptions } from "./types/conversation";
+export * from "./features/global-search/api";
+export * from "./features/global-search/hooks";
+export * from "./features/global-search/utils";
+export * from "./features/global-search/types";
+export * from "./constants";

package/dist/force-app/main/default/webapplications/appreactsampleb2e/src/lib/applicationAdapter.ts

@@ -0,0 +1,33 @@
+/**
+ * Adapter: maps Application__c GraphQL node to app Application type.
+ */
+import type { Application } from "./types.js";
+
+interface ApplicationNode {
+	Id?: string;
+	Name?: { value?: string };
+	Status__c?: { value?: string };
+	User__r?: { Name?: { value?: string } };
+	Property__r?: { Address__c?: { value?: string }; Name?: { value?: string } };
+	CreatedDate?: { value?: string };
+	Employment__c?: { value?: string };
+	References__c?: { value?: string };
+	Start_Date__c?: { value?: string };
+	[key: string]: unknown;
+}
+
+export function nodeToApplication(node: Record<string, unknown> | undefined): Application {
+	const n = (node ?? {}) as ApplicationNode;
+	const created = n.CreatedDate?.value;
+	return {
+		id: n.Id ?? "",
+		applicantName: n.User__r?.Name?.value ?? "Unknown",
+		propertyAddress: n.Property__r?.Address__c?.value ?? "",
+		submittedDate: created ? new Date(created).toLocaleDateString() : "",
+		status: n.Status__c?.value ?? "",
+		employment: n.Employment__c?.value,
+		references: n.References__c?.value,
+		startDate: n.Start_Date__c?.value,
+		propertyName: n.Property__r?.Name?.value,
+	};
+}

package/dist/force-app/main/default/webapplications/appreactsampleb2e/src/lib/applicationColumns.ts

@@ -0,0 +1,28 @@
+/**
+ * Column config for Application__c list.
+ */
+import type { Column } from "@salesforce/webapp-template-feature-react-global-search-experimental";
+
+export const APPLICATION_EXTRA_COLUMNS: Column[] = [
+	{ fieldApiName: "Name", label: "Name", searchable: true, sortable: true },
+	{ fieldApiName: "Status__c", label: "Status", searchable: true, sortable: true },
+	{ fieldApiName: "User__r.Name", label: "Applicant", searchable: true, sortable: false },
+	{
+		fieldApiName: "Property__r.Address__c",
+		label: "Property Address",
+		searchable: true,
+		sortable: false,
+	},
+	{ fieldApiName: "Property__r.Name", label: "Property Name", searchable: true, sortable: false },
+	{ fieldApiName: "CreatedDate", label: "Submitted", searchable: false, sortable: true },
+	{ fieldApiName: "Employment__c", label: "Employment", searchable: true, sortable: false },
+	{ fieldApiName: "References__c", label: "References", searchable: true, sortable: false },
+	{ fieldApiName: "Start_Date__c", label: "Start Date", searchable: false, sortable: true },
+];
+
+export function getApplicationListColumns(columns: Column[]): Column[] {
+	if (columns.length === 0) return APPLICATION_EXTRA_COLUMNS;
+	const existing = new Set(columns.map((c) => c.fieldApiName));
+	const toAdd = APPLICATION_EXTRA_COLUMNS.filter((c) => !existing.has(c.fieldApiName));
+	return toAdd.length === 0 ? columns : [...columns, ...toAdd];
+}

package/dist/force-app/main/default/webapplications/appreactsampleb2e/src/lib/constants.ts

@@ -0,0 +1,24 @@
+/**
+ * Application-wide constants.
+ */
+
+export const PAGE_SIZE_LIST = 12;
+export const DASHBOARD_MAINTENANCE_LIMIT = 5;
+
+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";

package/dist/force-app/main/default/webapplications/appreactsampleb2e/src/lib/fieldMappers.ts

@@ -0,0 +1,71 @@
+/**
+ * Maps Salesforce API field paths (from getObjectListFilters) to our app record properties.
+ * Used by applyFilterCriteria when filtering list data with FilterCriteria from the feature API.
+ */
+import type { Property, MaintenanceRequest, Application } from "./types.js";
+
+const PROPERTY_FIELD_MAP: Record<string, (p: Property) => string | number | undefined> = {
+	Name: (p) => p.name,
+	Address__c: (p) => p.address,
+	Type__c: (p) => p.type,
+	Status__c: (p) => p.status,
+	Description__c: (p) => p.description,
+	Monthly_Rent__c: (p) => p.monthlyRent,
+	Bedrooms__c: (p) => p.bedrooms,
+	Bathrooms__c: (p) => p.bathrooms,
+	Sq_Ft__c: (p) => p.sqFt,
+	Year_Built__c: (p) => p.yearBuilt,
+};
+
+const MAINTENANCE_REQUEST_FIELD_MAP: Record<
+	string,
+	(r: MaintenanceRequest) => string | number | undefined
+> = {
+	Status__c: (r) => r.status,
+	Type__c: (r) => r.issueType,
+	Description__c: (r) => r.description,
+	Priority__c: (r) => r.priority,
+	propertyAddress: (r) => r.propertyAddress,
+	tenantName: (r) => r.tenantName,
+	"Property__r.Address__c": (r) => r.propertyAddress,
+	"Property__r.Name": (r) => r.tenantUnit ?? r.propertyAddress,
+	"User__r.Name": (r) => r.tenantName,
+};
+
+const APPLICATION_FIELD_MAP: Record<string, (a: Application) => string | number | undefined> = {
+	Status__c: (a) => a.status,
+	Start_Date__c: (a) => a.submittedDate || a.startDate,
+	applicantName: (a) => a.applicantName,
+	propertyAddress: (a) => a.propertyAddress,
+	Employment__c: (a) => a.employment,
+	References__c: (a) => a.references,
+	"Property__r.Address__c": (a) => a.propertyAddress,
+	"Property__r.Name": (a) => a.propertyName ?? a.propertyAddress,
+};
+
+export function getPropertyRecordValue(
+	record: Property,
+	fieldPath: string,
+): string | number | undefined {
+	const getter = PROPERTY_FIELD_MAP[fieldPath];
+	if (getter) return getter(record);
+	return (record as unknown as Record<string, unknown>)[fieldPath] as string | number | undefined;
+}
+
+export function getMaintenanceRequestRecordValue(
+	record: MaintenanceRequest,
+	fieldPath: string,
+): string | number | undefined {
+	const getter = MAINTENANCE_REQUEST_FIELD_MAP[fieldPath];
+	if (getter) return getter(record);
+	return (record as unknown as Record<string, unknown>)[fieldPath] as string | number | undefined;
+}
+
+export function getApplicationRecordValue(
+	record: Application,
+	fieldPath: string,
+): string | number | undefined {
+	const getter = APPLICATION_FIELD_MAP[fieldPath];
+	if (getter) return getter(record);
+	return (record as unknown as Record<string, unknown>)[fieldPath] as string | number | undefined;
+}