@salesforce/templates 66.3.2 → 66.4.0

package/lib/templates/project/reactb2x/_p_/_m_/_w_/_a_/src/_f_/_gs_/api/objectInfoGraphQLService.ts

@@ -0,0 +1,137 @@
+/**
+ * Object metadata GraphQL service (uiapi.objectInfos).
+ *
+ * Single endpoint for object describe and picklist values. Used by objectInfoService
+ * to implement getObjectInfoBatch and getPicklistValues. Not used directly by UI.
+ *
+ * @module api/objectInfoGraphQLService
+ */
+
+import { getDataSDK, gql } from "@salesforce/sdk-data";
+import type {
+	GetObjectInfosQuery,
+	GetObjectInfosQueryVariables,
+	GetPicklistValuesQuery,
+	GetPicklistValuesQueryVariables,
+	ObjectInfoInput,
+} from "../types/schema";
+
+/**
+ * Builds objectInfos query (metadata only). Uses apiNames only — do not pass objectInfoInputs.
+ */
+const OBJECT_INFOS_QUERY = gql`
+	query GetObjectInfos($apiNames: [String!]!) {
+		uiapi {
+			objectInfos(apiNames: $apiNames) {
+				ApiName
+				label
+				labelPlural
+				nameFields
+				defaultRecordTypeId
+				keyPrefix
+				layoutable
+				queryable
+				searchable
+				updateable
+				deletable
+				createable
+				custom
+				mruEnabled
+				feedEnabled
+				fields {
+					ApiName
+					label
+					dataType
+					relationshipName
+					reference
+					compound
+					compoundFieldName
+					compoundComponentName
+					controllingFields
+					controllerName
+					referenceToInfos {
+						ApiName
+						nameFields
+					}
+				}
+				recordTypeInfos {
+					recordTypeId
+					name
+					master
+					available
+					defaultRecordTypeMapping
+				}
+				themeInfo {
+					color
+					iconUrl
+				}
+				childRelationships {
+					relationshipName
+					fieldName
+					childObjectApiName
+				}
+				dependentFields {
+					controllingField
+				}
+			}
+		}
+	}
+`;
+
+/**
+ * Builds objectInfos query with picklist values (API v65.0+).
+ * Schema requires objectInfos to be called with either apiNames or objectInfoInputs, not both.
+ * This query uses objectInfoInputs only.
+ * Optimized to only fetch fields used by extractPicklistValuesFromGraphQLObjectInfo.
+ */
+const PICKLIST_VALUES_QUERY = gql`
+	query GetPicklistValues($objectInfoInputs: [ObjectInfoInput!]!) {
+		uiapi {
+			objectInfos(objectInfoInputs: $objectInfoInputs) {
+				ApiName
+				fields {
+					ApiName
+					... on PicklistField {
+						picklistValuesByRecordTypeIDs {
+							recordTypeID
+							defaultValue {
+								value
+							}
+							picklistValues {
+								label
+								value
+								validFor
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+`;
+
+export async function queryForObjectInfos(apiNames: string[]): Promise<GetObjectInfosQuery> {
+	return runQuery<GetObjectInfosQuery, GetObjectInfosQueryVariables>(OBJECT_INFOS_QUERY, {
+		apiNames,
+	});
+}
+
+export async function queryForPicklistValues(
+	objectInfoInputs: ObjectInfoInput[],
+): Promise<GetPicklistValuesQuery> {
+	return runQuery<GetPicklistValuesQuery, GetPicklistValuesQueryVariables>(PICKLIST_VALUES_QUERY, {
+		objectInfoInputs,
+	});
+}
+
+async function runQuery<Q, V>(query: string, variables: V): Promise<Q> {
+	const data = await getDataSDK();
+	const response = await data.graphql?.<Q, V>(query, variables);
+
+	if (response?.errors?.length) {
+		const errorMessages = response.errors.map((e) => e.message).join("; ");
+		throw new Error(`GraphQL Error: ${errorMessages}`);
+	}
+
+	return response?.data ?? ({} as Q);
+}

package/lib/templates/project/reactb2x/_p_/_m_/_w_/_a_/src/_f_/_gs_/api/objectInfoService.ts

@@ -0,0 +1,95 @@
+import { uiApiClient } from "@salesforce/webapp-experimental/api";
+import type { Filter } from "../types/filters/filters";
+import { FilterArraySchema } from "../types/filters/filters";
+import type { PicklistValue } from "../types/filters/picklist";
+import type { ObjectInfoBatchResponse } from "../types/objectInfo/objectInfo";
+import { fetchAndValidate, safeEncodePath } from "../utils/apiUtils";
+import { queryForObjectInfos, queryForPicklistValues } from "./objectInfoGraphQLService";
+import {
+	graphQLObjectInfosToBatchResponse,
+	extractPicklistValuesFromGraphQLObjectInfo,
+} from "../utils/graphQLObjectInfoAdapter";
+
+/**
+ * Object info and search service.
+ *
+ * - getObjectInfoBatch / getPicklistValues: GraphQL (objectInfoGraphQLService).
+ * - getObjectListFilters: REST (search-info).
+ * Hooks use this service; components do not call it directly.
+ *
+ * @module api/objectInfoService
+ */
+
+/** Cache key: sorted, comma-joined object API names. */
+function getObjectInfoBatchCacheKey(objectApiNames: string): string {
+	const names = objectApiNames
+		.split(",")
+		.map((s) => s.trim())
+		.filter(Boolean);
+	return [...names].sort().join(",");
+}
+
+const objectInfoBatchCache = new Map<string, ObjectInfoBatchResponse>();
+const objectInfoBatchInFlight = new Map<string, Promise<ObjectInfoBatchResponse>>();
+
+export async function getObjectInfoBatch(objectApiNames: string): Promise<ObjectInfoBatchResponse> {
+	const names = objectApiNames
+		.split(",")
+		.map((s) => s.trim())
+		.filter(Boolean);
+	if (names.length === 0) {
+		return { results: [] };
+	}
+	const key = getObjectInfoBatchCacheKey(objectApiNames);
+	const cached = objectInfoBatchCache.get(key);
+	if (cached) return Promise.resolve(cached);
+	const inFlight = objectInfoBatchInFlight.get(key);
+	if (inFlight) return inFlight;
+	const promise = (async () => {
+		try {
+			const response = await queryForObjectInfos(names);
+			const nodes = response?.uiapi?.objectInfos ?? [];
+			const result = graphQLObjectInfosToBatchResponse(nodes, names);
+			objectInfoBatchCache.set(key, result);
+			return result;
+		} finally {
+			objectInfoBatchInFlight.delete(key);
+		}
+	})();
+	objectInfoBatchInFlight.set(key, promise);
+	return promise;
+}
+
+export async function getObjectListFilters(objectApiName: string): Promise<Filter[]> {
+	return fetchAndValidate(
+		() => uiApiClient.get(`/search-info/${safeEncodePath(objectApiName)}/filters`),
+		{
+			schema: FilterArraySchema,
+			errorContext: `filters for ${objectApiName}`,
+			extractData: (data: unknown) => {
+				if (!data) return [];
+				return Array.isArray(data) ? data : (data as { filters?: unknown }).filters || [];
+			},
+		},
+	);
+}
+
+export async function getPicklistValues(
+	objectApiName: string,
+	fieldName: string,
+	recordTypeId: string = "012000000000000AAA",
+): Promise<PicklistValue[]> {
+	const response = await queryForPicklistValues([
+		{ apiName: objectApiName, fieldNames: [fieldName] },
+	]);
+	const nodes = response?.uiapi?.objectInfos ?? [];
+	const node = nodes[0];
+	if (!node) return [];
+	return extractPicklistValuesFromGraphQLObjectInfo(node, fieldName, recordTypeId);
+}
+
+export const objectInfoService = {
+	getObjectInfoBatch,
+	getObjectListFilters,
+	getPicklistValues,
+};

package/lib/templates/project/{reactb2e/force-app/main/default/webapplications/appreacttemplateb2e/src/features/global-search → reactb2x/_p_/_m_/_w_/_a_/src/_f_/_gs_}/api/recordListGraphQLService.ts

@@ -149,10 +149,9 @@ export function buildWhereFromCriteria(
 
 	for (const c of criteria) {
 		if (!c.fieldPath || !c.operator || !c.values?.length) continue;
-		const value = c.values[0];
 		const op = c.operator;
 		const parts = c.fieldPath.split(".");
-		const fieldClause = { [op]: value };
+		const fieldClause = op === "in" ? { in: c.values } : { [op]: c.values[0] };
 		if (parts.length === 1) {
 			conditions.push({ [parts[0]]: fieldClause });
 		} else {

package/lib/templates/project/{reactb2e/force-app/main/default/webapplications/appreacttemplateb2e/src/features/global-search → reactb2x/_p_/_m_/_w_/_a_/src/_f_/_gs_}/hooks/useObjectInfoBatch.ts

@@ -44,7 +44,7 @@ export function useObjectInfoBatch(objectApiNames: string[]): UseObjectInfoBatch
 			.then((res) => {
 				if (isCancelled.current) return;
 				const objectInfos = names
-					.map((apiName) => res.results?.find((r) => r.result?.apiName === apiName)?.result)
+					.map((apiName) => res.results?.find((r) => r.result?.ApiName === apiName)?.result)
 					.filter((r) => r != null) as ObjectInfoResult[];
 				setState({ objectInfos, loading: false, error: null });
 			})

package/lib/templates/project/reactb2x/_p_/_m_/_w_/_a_/src/_f_/_gs_/hooks/useObjectSearchData.ts

@@ -0,0 +1,174 @@
+/**
+ * Object Search Data Hooks
+ *
+ * - useObjectListMetadata: single source for list-view metadata (filters → columns + picklists). Use in list pages to avoid duplicate state and API calls.
+ * - useObjectColumns / useObjectFilters: thin wrappers over useObjectListMetadata for backward compatibility.
+ * - getSharedFilters: module-level deduplication for getObjectListFilters across hook instances.
+ */
+
+import { useState, useEffect } from "react";
+import { objectInfoService } from "../api/objectInfoService";
+import type { Column } from "../types/search/searchResults";
+import type { Filter } from "../types/filters/filters";
+import type { PicklistValue } from "../types/filters/picklist";
+
+// --- Shared filters cache (deduplicates getObjectListFilters across useObjectColumns + useObjectFilters) ---
+const sharedFiltersCache = new Map<string, Filter[]>();
+const sharedFiltersInFlight = new Map<string, Promise<Filter[]>>();
+
+function getSharedFilters(objectApiName: string): Promise<Filter[]> {
+	const cached = sharedFiltersCache.get(objectApiName);
+	if (cached) return Promise.resolve(cached);
+	const inFlight = sharedFiltersInFlight.get(objectApiName);
+	if (inFlight) return inFlight;
+	const promise = objectInfoService
+		.getObjectListFilters(objectApiName)
+		.then((filters) => {
+			sharedFiltersCache.set(objectApiName, filters);
+			sharedFiltersInFlight.delete(objectApiName);
+			return filters;
+		})
+		.catch((err) => {
+			sharedFiltersInFlight.delete(objectApiName);
+			throw err;
+		});
+	sharedFiltersInFlight.set(objectApiName, promise);
+	return promise;
+}
+
+// --- Shared Types ---
+export interface FiltersData {
+	filters: Filter[];
+	picklistValues: Record<string, PicklistValue[]>;
+	loading: boolean;
+	error: string | null;
+}
+
+/**
+ * Derives column definitions from filter definitions for list/result UI.
+ */
+function filtersToColumns(filters: Filter[]): Column[] {
+	return filters.map((f) => ({
+		fieldApiName: f.targetFieldPath,
+		label: f.label,
+		searchable: true,
+		sortable: true,
+	}));
+}
+
+export interface ObjectListMetadata {
+	columns: Column[];
+	filters: Filter[];
+	picklistValues: Record<string, PicklistValue[]>;
+	loading: boolean;
+	error: string | null;
+}
+
+/**
+ * Single hook for list-view metadata: filters (shared API), derived columns, and picklist values.
+ * Use this in list/search pages to avoid duplicate useObjectColumns + useObjectFilters and duplicate state.
+ */
+export function useObjectListMetadata(objectApiName: string | null): ObjectListMetadata {
+	const [state, setState] = useState<{
+		columns: Column[];
+		filters: Filter[];
+		picklistValues: Record<string, PicklistValue[]>;
+		loading: boolean;
+		error: string | null;
+	}>({
+		columns: [],
+		filters: [],
+		picklistValues: {},
+		loading: true,
+		error: null,
+	});
+
+	useEffect(() => {
+		if (!objectApiName) {
+			setState((s) => ({ ...s, loading: false, error: "Invalid object" }));
+			return;
+		}
+
+		let isCancelled = false;
+
+		const run = async () => {
+			setState((s) => ({ ...s, loading: true, error: null }));
+			try {
+				const filters = await getSharedFilters(objectApiName!);
+				if (isCancelled) return;
+
+				const selectFilters = filters.filter((f) => f.affordance?.toLowerCase() === "select");
+				const picklistPromises = selectFilters.map((f) =>
+					objectInfoService
+						.getPicklistValues(objectApiName!, f.targetFieldPath)
+						.then((values) => ({ fieldPath: f.targetFieldPath, values }))
+						.catch(() => ({ fieldPath: f.targetFieldPath, values: [] as PicklistValue[] })),
+				);
+				const picklistResults = await Promise.all(picklistPromises);
+				if (isCancelled) return;
+
+				const picklistValues: Record<string, PicklistValue[]> = {};
+				picklistResults.forEach(({ fieldPath, values }) => {
+					picklistValues[fieldPath] = values;
+				});
+
+				setState({
+					columns: filtersToColumns(filters),
+					filters,
+					picklistValues,
+					loading: false,
+					error: null,
+				});
+			} catch (err) {
+				if (isCancelled) return;
+				setState((s) => ({
+					...s,
+					columns: [],
+					filters: [],
+					picklistValues: {},
+					loading: false,
+					error: "Failed to load list metadata",
+				}));
+			}
+		};
+
+		run();
+		return () => {
+			isCancelled = true;
+		};
+	}, [objectApiName]);
+
+	return state;
+}
+
+/**
+ * Hook: useObjectColumns
+ * Thin wrapper over useObjectListMetadata for backward compatibility.
+ */
+export function useObjectColumns(objectApiName: string | null) {
+	const { columns, loading, error } = useObjectListMetadata(objectApiName);
+	return {
+		columns: objectApiName ? columns : [],
+		columnsLoading: loading,
+		columnsError: error,
+	};
+}
+
+/**
+ * Hook: useObjectFilters
+ * Thin wrapper over useObjectListMetadata for backward compatibility.
+ */
+export function useObjectFilters(objectApiName: string | null) {
+	const { filters, picklistValues, loading, error } = useObjectListMetadata(objectApiName);
+	const filtersData: Record<string, FiltersData> = objectApiName
+		? {
+				[objectApiName]: {
+					filters,
+					picklistValues,
+					loading,
+					error,
+				},
+			}
+		: {};
+	return { filtersData };
+}

package/lib/templates/project/{reactb2e/force-app/main/default/webapplications/appreacttemplateb2e/src/features/global-search → reactb2x/_p_/_m_/_w_/_a_/src/_f_/_gs_}/hooks/useRecordDetailLayout.ts

@@ -16,7 +16,6 @@ export interface UseRecordDetailLayoutParams {
 	objectApiName: string | null;
 	recordId: string | null;
 	recordTypeId?: string | null;
-	/** When provided, skips the fetch and uses this data (avoids duplicate API calls when parent already fetched). Callers should memoize this (e.g. useMemo) to avoid unnecessary effect runs. */
 	initialData?: {
 		layout: LayoutResponse;
 		record: GraphQLRecordNode;
@@ -25,7 +24,6 @@ export interface UseRecordDetailLayoutParams {
 }
 
 const MAX_CACHE_SIZE = 50;
-/** Cache entries older than this are treated as stale and refetched. */
 const CACHE_TTL_MS = 5 * 60 * 1000;
 
 type CacheEntry = {
@@ -35,17 +33,6 @@ type CacheEntry = {
 	cachedAt: number;
 };
 
-/**
- * Detail page data: layout (REST), object metadata (GraphQL), single record (GraphQL).
- *
- * Calls objectDetailService.getRecordDetail once per objectApiName/recordId/recordTypeId.
- * Caches result in memory (TTL 5min, max 50 entries). Used by DetailPage and UiApiDetailForm.
- *
- * @param objectApiName - Object API name.
- * @param recordId - Record Id.
- * @param recordTypeId - Optional record type (default master).
- * @returns { layout, record, objectMetadata, loading, error }.
- */
 export function useRecordDetailLayout({
 	objectApiName,
 	recordId,
@@ -71,7 +58,6 @@ export function useRecordDetailLayout({
 			return;
 		}
 
-		// Skip fetch when parent already provided data (avoids duplicate API calls)
 		if (
 			initialData?.layout != null &&
 			initialData?.record != null &&
@@ -92,7 +78,6 @@ export function useRecordDetailLayout({
 		}
 
 		let isCancelled = false;
-		const abortController = new AbortController();
 
 		const fetchDetail = async () => {
 			setLoading(true);
@@ -107,7 +92,6 @@ export function useRecordDetailLayout({
 					objectApiName,
 					recordId,
 					recordTypeId ?? undefined,
-					abortController.signal,
 				);
 
 				if (isCancelled) return;
@@ -127,9 +111,7 @@ export function useRecordDetailLayout({
 				setRecord(recordData);
 				setObjectMetadata(objectMetadataData);
 			} catch (err) {
-				if (isCancelled || (err instanceof Error && err.name === "AbortError")) {
-					return;
-				}
+				if (isCancelled) return;
 				setError("Failed to load record details");
 			} finally {
 				if (!isCancelled) {
@@ -142,7 +124,6 @@ export function useRecordDetailLayout({
 
 		return () => {
 			isCancelled = true;
-			abortController.abort();
 		};
 	}, [objectApiName, recordId, recordTypeId, cacheKey, initialData]);
 

package/lib/templates/project/{reactb2e/force-app/main/default/webapplications/appreacttemplateb2e/src/features/global-search → reactb2x/_p_/_m_/_w_/_a_/src/_f_/_gs_}/pages/DetailPage.tsx

@@ -6,7 +6,7 @@ import { Alert, AlertDescription, AlertTitle } from "../../../components/ui/aler
 import { AlertCircle } from "lucide-react";
 import DetailHeader from "../components/detail/DetailHeader";
 import { UiApiDetailForm } from "../components/detail/UiApiDetailForm";
-import { OBJECT_API_NAMES, DEFAULT_DETAIL_PAGE_TITLE } from "../../../constants";
+import { OBJECT_API_NAMES, DEFAULT_DETAIL_PAGE_TITLE } from "../constants";
 import { toRecordDisplayNameMetadata } from "../utils/fieldUtils";
 import { useRecordDetailLayout } from "../hooks/useRecordDetailLayout";
 import { getGraphQLRecordDisplayName } from "../utils/graphQLNodeFieldUtils";

package/lib/templates/project/{reactb2e/force-app/main/default/webapplications/appreacttemplateb2e/src/features/global-search → reactb2x/_p_/_m_/_w_/_a_/src/_f_/_gs_}/pages/GlobalSearch.tsx

@@ -13,7 +13,7 @@
  */
 import { useMemo, useState, useCallback, useEffect, useRef } from "react";
 import { useParams } from "react-router";
-import { OBJECT_API_NAMES, DEFAULT_PAGE_SIZE } from "../../../constants";
+import { OBJECT_API_NAMES, DEFAULT_PAGE_SIZE } from "../constants";
 import { useObjectListMetadata } from "../hooks/useObjectSearchData";
 import { useObjectInfoBatch } from "../hooks/useObjectInfoBatch";
 import { useRecordListGraphQL } from "../hooks/useRecordListGraphQL";

package/lib/templates/project/reactb2x/{force-app/main/default/webapplications/appreacttemplateb2x/src/features/global-search → _p_/_m_/_w_/_a_/src/_f_/_gs_}/types/filters/filters.ts

@@ -12,6 +12,7 @@ export const FILTER_OPERATORS = [
 	"eq", // Equals
 	"ne", // Not equals
 	"like", // Pattern matching (contains)
+	"in", // In list (multiple values)
 	"gt", // Greater than
 	"gte", // Greater than or equal
 	"lt", // Less than

package/lib/templates/project/reactb2x/_p_/_m_/_w_/_a_/src/_f_/_gs_/types/filters/picklist.ts

@@ -0,0 +1,6 @@
+import type { PicklistValue as GraphQLPicklistValue } from "../objectInfo/objectInfo";
+
+export type PicklistValue = GraphQLPicklistValue & {
+	value: NonNullable<GraphQLPicklistValue["value"]>;
+	label: NonNullable<GraphQLPicklistValue["label"]>;
+};

package/lib/templates/project/reactb2x/_p_/_m_/_w_/_a_/src/_f_/_gs_/types/objectInfo/objectInfo.ts

@@ -0,0 +1,49 @@
+import type { GetObjectInfosQuery, GetPicklistValuesQuery } from "../schema";
+
+// Generic utility types for extracting array item types
+type ArrayItem<T> = T extends (infer Item)[] ? Item : never;
+type NonNullableArrayItem<T> = NonNullable<ArrayItem<NonNullable<T>>>;
+
+// ObjectInfos extraction
+export type GetObjectInfosQueryObjectInfos = NonNullable<
+	GetObjectInfosQuery["uiapi"]["objectInfos"]
+>;
+export type GetObjectInfosQueryObjectInfo = NonNullableArrayItem<GetObjectInfosQueryObjectInfos>;
+export type GetObjectInfosQueryField = NonNullableArrayItem<
+	GetObjectInfosQueryObjectInfo["fields"]
+>;
+
+// ObjectInfoResult types
+export type ObjectInfoResult = Omit<GetObjectInfosQueryObjectInfo, "fields"> & {
+	fields: Record<string, GetObjectInfosQueryField>;
+};
+export type ObjectInfoBatchResponse = {
+	results: { result: ObjectInfoResult; statusCode: number }[];
+};
+
+// Picklist values extraction
+export type GetPicklistValuesQueryObjectInfos = GetPicklistValuesQuery["uiapi"]["objectInfos"];
+export type GetPicklistValuesQueryObjectInfo =
+	NonNullableArrayItem<GetPicklistValuesQueryObjectInfos>;
+export type GetPicklistValuesQueryField = NonNullableArrayItem<
+	GetPicklistValuesQueryObjectInfo["fields"]
+>;
+
+// Extract picklist-specific field type (the one with picklistValuesByRecordTypeIDs)
+type GetPicklistValuesQueryPicklistField = Extract<
+	GetPicklistValuesQueryField,
+	{ picklistValuesByRecordTypeIDs?: unknown }
+>;
+
+// Extract types from picklistValuesByRecordTypeIDs
+type PicklistValuesByRecordTypeIDs =
+	GetPicklistValuesQueryPicklistField["picklistValuesByRecordTypeIDs"];
+type PicklistValuesByRecordTypeID = NonNullable<
+	NonNullable<PicklistValuesByRecordTypeIDs> extends (infer Item)[] ? Item : null
+>;
+
+// Extract individual picklist value type
+type PicklistValues = NonNullable<PicklistValuesByRecordTypeID>["picklistValues"];
+export type PicklistValue = NonNullable<
+	NonNullable<PicklistValues> extends (infer Item)[] ? Item : null
+>;