@salesforce/templates 66.3.2 → 66.4.0

package/lib/templates/project/reactb2e/_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/{reactb2x/force-app/main/default/webapplications/appreacttemplateb2x/src/features/global-search → reactb2e/_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/{reactb2x/force-app/main/default/webapplications/appreacttemplateb2x/src/features/global-search → reactb2e/_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/{reactb2x/force-app/main/default/webapplications/appreacttemplateb2x/src/features/global-search → reactb2e/_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/reactb2e/{force-app/main/default/webapplications/appreacttemplateb2e/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/reactb2e/_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/reactb2e/_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
+>;

package/lib/templates/project/reactb2e/_p_/_m_/_w_/_a_/src/_f_/_gs_/types/schema.d.ts

@@ -0,0 +1,200 @@
+export type Maybe<T> = T | null;
+export type InputMaybe<T> = Maybe<T>;
+export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> };
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> };
+export type MakeEmpty<T extends { [key: string]: unknown }, K extends keyof T> = {
+	[_ in K]?: never;
+};
+export type Incremental<T> =
+	| T
+	| { [P in keyof T]?: P extends " $fragmentName" | "__typename" ? T[P] : never };
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+	ID: { input: string; output: string };
+	String: { input: string; output: string };
+	Boolean: { input: boolean; output: boolean };
+	Int: { input: number; output: number };
+	Float: { input: number; output: number };
+	Base64: { input: string; output: string };
+	/** An arbitrary precision signed decimal */
+	BigDecimal: { input: number | string; output: number };
+	/** An arbitrary precision signed integer */
+	BigInteger: { input: number; output: number };
+	/** An 8-bit signed integer */
+	Byte: { input: number; output: number };
+	/** A UTF-16 code unit; a character on Unicode's BMP */
+	Char: { input: number; output: number };
+	Currency: { input: number | string; output: number };
+	Date: { input: string; output: string };
+	DateTime: { input: string; output: string };
+	Double: { input: number | string; output: number };
+	Email: { input: string; output: string };
+	EncryptedString: { input: string; output: string };
+	/** Can be set to an ID or a Reference to the result of another mutation operation. */
+	IdOrRef: { input: string; output: string };
+	JSON: { input: string; output: string };
+	Latitude: { input: number | string; output: number };
+	/** A 64-bit signed integer */
+	Long: { input: number; output: number };
+	LongTextArea: { input: string; output: string };
+	Longitude: { input: number | string; output: number };
+	MultiPicklist: { input: string; output: string };
+	Percent: { input: number | string; output: number };
+	PhoneNumber: { input: string; output: string };
+	Picklist: { input: string; output: string };
+	RichTextArea: { input: string; output: string };
+	/** A 16-bit signed integer */
+	Short: { input: number; output: number };
+	TextArea: { input: string; output: string };
+	Time: { input: string; output: string };
+	Url: { input: string; output: string };
+};
+
+export enum DataType {
+	Address = "ADDRESS",
+	Anytype = "ANYTYPE",
+	Base64 = "BASE64",
+	Boolean = "BOOLEAN",
+	Combobox = "COMBOBOX",
+	Complexvalue = "COMPLEXVALUE",
+	Currency = "CURRENCY",
+	Date = "DATE",
+	Datetime = "DATETIME",
+	Double = "DOUBLE",
+	Email = "EMAIL",
+	Encryptedstring = "ENCRYPTEDSTRING",
+	Int = "INT",
+	Json = "JSON",
+	Junctionidlist = "JUNCTIONIDLIST",
+	Location = "LOCATION",
+	Long = "LONG",
+	Multipicklist = "MULTIPICKLIST",
+	Percent = "PERCENT",
+	Phone = "PHONE",
+	Picklist = "PICKLIST",
+	Reference = "REFERENCE",
+	String = "STRING",
+	Textarea = "TEXTAREA",
+	Time = "TIME",
+	Url = "URL",
+}
+
+export enum FieldExtraTypeInfo {
+	ExternalLookup = "EXTERNAL_LOOKUP",
+	ImageUrl = "IMAGE_URL",
+	IndirectLookup = "INDIRECT_LOOKUP",
+	Personname = "PERSONNAME",
+	Plaintextarea = "PLAINTEXTAREA",
+	Richtextarea = "RICHTEXTAREA",
+	SwitchablePersonname = "SWITCHABLE_PERSONNAME",
+}
+
+/** Input for ObjectInfo and PickValues */
+export type ObjectInfoInput = {
+	apiName: Scalars["String"]["input"];
+	fieldNames?: InputMaybe<Array<Scalars["String"]["input"]>>;
+	recordTypeIDs?: InputMaybe<Array<Scalars["ID"]["input"]>>;
+};
+
+export enum ResultOrder {
+	Asc = "ASC",
+	Desc = "DESC",
+}
+
+export type GetObjectInfosQueryVariables = Exact<{
+	apiNames: Array<Scalars["String"]["input"]> | Scalars["String"]["input"];
+}>;
+
+export type GetObjectInfosQuery = {
+	uiapi: {
+		objectInfos?: Array<{
+			ApiName: string;
+			label?: string | null;
+			labelPlural?: string | null;
+			nameFields: Array<string | null>;
+			defaultRecordTypeId?: string | null;
+			keyPrefix?: string | null;
+			layoutable: boolean;
+			queryable: boolean;
+			searchable: boolean;
+			updateable: boolean;
+			deletable: boolean;
+			createable: boolean;
+			custom: boolean;
+			mruEnabled: boolean;
+			feedEnabled: boolean;
+			fields: Array<
+				| {
+						ApiName: string;
+						label?: string | null;
+						dataType?: DataType | null;
+						relationshipName?: string | null;
+						reference: boolean;
+						compound: boolean;
+						compoundFieldName?: string | null;
+						compoundComponentName?: string | null;
+						controllingFields: Array<string | null>;
+						controllerName?: string | null;
+						referenceToInfos: Array<{ ApiName: string; nameFields: Array<string | null> } | null>;
+				  }
+				| {
+						ApiName: string;
+						label?: string | null;
+						dataType?: DataType | null;
+						relationshipName?: string | null;
+						reference: boolean;
+						compound: boolean;
+						compoundFieldName?: string | null;
+						compoundComponentName?: string | null;
+						controllingFields: Array<string | null>;
+						controllerName?: string | null;
+						referenceToInfos: Array<{ ApiName: string; nameFields: Array<string | null> } | null>;
+				  }
+				| null
+			>;
+			recordTypeInfos: Array<{
+				recordTypeId?: string | null;
+				name?: string | null;
+				master: boolean;
+				available: boolean;
+				defaultRecordTypeMapping: boolean;
+			} | null>;
+			themeInfo?: { color?: string | null; iconUrl?: string | null } | null;
+			childRelationships: Array<{
+				relationshipName?: string | null;
+				fieldName?: string | null;
+				childObjectApiName: string;
+			} | null>;
+			dependentFields: Array<{ controllingField: string } | null>;
+		} | null> | null;
+	};
+};
+
+export type GetPicklistValuesQueryVariables = Exact<{
+	objectInfoInputs: Array<ObjectInfoInput> | ObjectInfoInput;
+}>;
+
+export type GetPicklistValuesQuery = {
+	uiapi: {
+		objectInfos?: Array<{
+			ApiName: string;
+			fields: Array<
+				| {
+						ApiName: string;
+						picklistValuesByRecordTypeIDs?: Array<{
+							recordTypeID: string;
+							defaultValue?: { value?: string | null } | null;
+							picklistValues?: Array<{
+								label?: string | null;
+								value?: string | null;
+								validFor?: Array<number | null> | null;
+							}> | null;
+						} | null> | null;
+				  }
+				| { ApiName: string }
+				| null
+			>;
+		} | null> | null;
+	};
+};

package/lib/templates/project/reactb2e/_p_/_m_/_w_/_a_/src/_f_/_gs_/utils/apiUtils.ts

@@ -0,0 +1,59 @@
+/**
+ * API Utilities
+ *
+ * Generic utility functions for API requests, validation, and URL handling.
+ */
+
+import type { ZodSchema } from "zod";
+
+export interface FetchAndValidateOptions<T> {
+	schema: ZodSchema<T>;
+	errorContext: string;
+	extractData?: (data: unknown) => unknown;
+}
+
+export async function fetchAndValidate<T>(
+	fetchFn: () => Promise<Response>,
+	options: FetchAndValidateOptions<T>,
+): Promise<T> {
+	const { schema, errorContext, extractData } = options;
+
+	try {
+		const response = await fetchFn();
+
+		if (!response.ok) {
+			throw new Error(`Failed to fetch ${errorContext}: ${response.status} ${response.statusText}`);
+		}
+
+		const data = await response.json();
+		const dataToValidate = extractData ? extractData(data) : data;
+		const validationResult = schema.safeParse(dataToValidate);
+
+		if (!validationResult.success) {
+			throw new Error(`Invalid ${errorContext} response format: ${validationResult.error.message}`);
+		}
+
+		return validationResult.data;
+	} catch (error) {
+		if (error instanceof Error && error.name === "ZodError") {
+			throw new Error(`Invalid ${errorContext} response format: ${error.message}`);
+		}
+
+		if (
+			error instanceof Error &&
+			(error.message.includes("Failed to fetch") || error.message.includes("Invalid"))
+		) {
+			throw error;
+		}
+
+		throw new Error(
+			`Error fetching ${errorContext}: ${
+				error instanceof Error ? error.message : (error?.toString() ?? "Unknown error")
+			}`,
+		);
+	}
+}
+
+export function safeEncodePath(segment: string): string {
+	return encodeURIComponent(segment);
+}

package/lib/templates/project/reactb2e/_p_/_m_/_w_/_a_/src/_f_/_gs_/utils/graphQLObjectInfoAdapter.ts

@@ -0,0 +1,77 @@
+/**
+ * GraphQL objectInfos → REST-compatible object info and picklist.
+ *
+ * graphQLObjectInfoToObjectInfoResult / graphQLObjectInfosToBatchResponse: used by objectInfoService
+ * after getObjectInfosGraphQL. extractPicklistValuesFromGraphQLObjectInfo: used for getPicklistValues.
+ * Normalizes casing and adds synthetic compound fields (e.g. BillingAddress) for layout/dataType.
+ *
+ * @module utils/graphQLObjectInfoAdapter
+ */
+
+import type {
+	ObjectInfoBatchResponse,
+	GetObjectInfosQueryObjectInfos,
+	GetPicklistValuesQueryObjectInfo,
+	GetPicklistValuesQueryField,
+	GetObjectInfosQueryObjectInfo,
+	ObjectInfoResult,
+	PicklistValue as GraphQLPicklistValue,
+} from "../types/objectInfo/objectInfo";
+import type { PicklistValue } from "../types/filters/picklist";
+
+export function graphQLObjectInfoToObjectInfoResult(
+	objectInfo: GetObjectInfosQueryObjectInfo,
+): ObjectInfoResult {
+	const { fields, ...rest } = objectInfo;
+	const fieldsRecord = Object.fromEntries((fields ?? []).map((field) => [field?.ApiName, field]));
+	return {
+		...rest,
+		fields: fieldsRecord,
+	};
+}
+
+/** Convert GraphQL objectInfos array to ObjectInfoBatchResponse (REST shape). */
+export function graphQLObjectInfosToBatchResponse(
+	objectInfos: GetObjectInfosQueryObjectInfos,
+	_requestedApiNames: string[],
+): ObjectInfoBatchResponse {
+	const results = objectInfos.map((objectInfo) => ({
+		result: graphQLObjectInfoToObjectInfoResult(objectInfo!),
+		statusCode: 200,
+	}));
+	return { results };
+}
+
+/**
+ * Extract picklist values for a field from a GraphQL ObjectInfo node (raw response).
+ * Uses picklistValuesByRecordTypeIDs; prefers the given recordTypeId or first available.
+ */
+export function extractPicklistValuesFromGraphQLObjectInfo(
+	objectInfo: NonNullable<GetPicklistValuesQueryObjectInfo>,
+	fieldName: string,
+	recordTypeId?: string,
+): PicklistValue[] {
+	const fields = objectInfo.fields;
+	if (fields == null) return [];
+	const fieldMap: Record<string, GetPicklistValuesQueryField> = Object.fromEntries(
+		fields.map((field) => {
+			return [field?.ApiName, field];
+		}),
+	);
+	const field = fieldMap[fieldName];
+	if (!field) return [];
+	const picklistData =
+		"picklistValuesByRecordTypeIDs" in field ? field.picklistValuesByRecordTypeIDs : undefined;
+	if (!picklistData) return [];
+	const rtId = recordTypeId ?? "012000000000000AAA";
+	const byRecordType = picklistData.find((p) => p!.recordTypeID === rtId) ?? picklistData[0];
+	return mapPicklistValues(byRecordType?.picklistValues ?? []);
+}
+
+function mapPicklistValues(values: GraphQLPicklistValue[]): PicklistValue[] {
+	return values.map((item) => ({
+		...item,
+		value: item.value ?? "",
+		label: item.label ?? "",
+	}));
+}