@salesforce/webapp-template-app-react-template-b2x-experimental 1.76.1 → 1.77.0

package/dist/CHANGELOG.md

@@ -3,6 +3,14 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [1.77.0](https://github.com/salesforce-experience-platform-emu/webapps/compare/v1.76.1...v1.77.0) (2026-03-06)
+
+**Note:** Version bump only for package @salesforce/webapp-template-base-sfdx-project-experimental
+
+
+
+
+
 ## [1.76.1](https://github.com/salesforce-experience-platform-emu/webapps/compare/v1.76.0...v1.76.1) (2026-03-06)
 
 **Note:** Version bump only for package @salesforce/webapp-template-base-sfdx-project-experimental

package/dist/force-app/main/default/webapplications/appreacttemplateb2x/package.json

@@ -15,8 +15,8 @@
     "graphql:schema": "node scripts/get-graphql-schema.mjs"
   },
   "dependencies": {
-    "@salesforce/sdk-data": "^1.76.1",
-    "@salesforce/webapp-experimental": "^1.76.1",
+    "@salesforce/sdk-data": "^1.77.0",
+    "@salesforce/webapp-experimental": "^1.77.0",
     "@tailwindcss/vite": "^4.1.17",
     "@tanstack/react-form": "^1.28.4",
     "class-variance-authority": "^0.7.1",
@@ -40,7 +40,7 @@
     "@graphql-eslint/eslint-plugin": "^4.1.0",
     "@graphql-tools/utils": "^11.0.0",
     "@playwright/test": "^1.49.0",
-    "@salesforce/vite-plugin-webapp-experimental": "^1.76.1",
+    "@salesforce/vite-plugin-webapp-experimental": "^1.77.0",
     "@testing-library/jest-dom": "^6.6.3",
     "@testing-library/react": "^16.1.0",
     "@testing-library/user-event": "^14.5.2",

package/dist/force-app/main/default/webapplications/appreacttemplateb2x/src/features/global-search/api/objectInfoGraphQLService.ts

@@ -7,179 +7,131 @@
  * @module api/objectInfoGraphQLService
  */
 
-import { getDataSDK } from "@salesforce/sdk-data";
-
-/** GraphQL objectInfoInputs for requesting picklist values (API v65.0+). Only apiName and fieldNames are sent; record type filtering is done from the response. */
-export interface ObjectInfoInput {
-	apiName: string;
-	fieldNames?: string[] | null;
-}
-
-/** Raw GraphQL response shape for uiapi.objectInfos (flexible for schema casing). */
-export interface ObjectInfosGraphQLResponse {
-	uiapi?: {
-		objectInfos?: Array<Record<string, unknown>>;
-	};
-}
+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.
  */
-function buildObjectInfosQuery(): string {
-	return `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
-      }
-    }
-  }
-}`;
-}
+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.
  */
-function buildObjectInfosWithPicklistsQuery(): string {
-	return `query GetPicklistValues($objectInfoInputs: [ObjectInfoInput!]!) {
-  uiapi {
-    objectInfos(objectInfoInputs: $objectInfoInputs) {
-      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
-        }
-        ... on PicklistField {
-          picklistValuesByRecordTypeIDs {
-            recordTypeID
-            defaultValue {
-              value
-            }
-            picklistValues {
-              label
-              value
-              validFor
-            }
-          }
-        }
-      }
-      recordTypeInfos {
-        recordTypeId
-        name
-        master
-        available
-        defaultRecordTypeMapping
-      }
-      themeInfo {
-        color
-        iconUrl
-      }
-      childRelationships {
-        relationshipName
-        fieldName
-        childObjectApiName
-      }
-      dependentFields {
-        controllingField
-      }
-    }
-  }
-}`;
+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,
+	});
 }
 
-export async function getObjectInfosGraphQL(
-	apiNames: string[],
-	options?: {
-		objectInfoInputs?: ObjectInfoInput[] | null;
-	},
-): Promise<ObjectInfosGraphQLResponse> {
-	const names = apiNames.length ? apiNames : [];
-	const hasInputs = options?.objectInfoInputs != null && options.objectInfoInputs.length > 0;
-	const query = hasInputs ? buildObjectInfosWithPicklistsQuery() : buildObjectInfosQuery();
-	const variables: Record<string, unknown> = hasInputs
-		? { objectInfoInputs: options!.objectInfoInputs }
-		: { apiNames: names };
+async function runQuery<Q, V>(query: string, variables: V): Promise<Q> {
 	const data = await getDataSDK();
-	const response = await data.graphql?.<ObjectInfosGraphQLResponse>(query, variables);
+	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 ObjectInfosGraphQLResponse);
+	return response?.data ?? ({} as Q);
 }

package/dist/force-app/main/default/webapplications/appreacttemplateb2x/src/features/global-search/api/objectInfoService.ts

@@ -4,7 +4,7 @@ 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 { getObjectInfosGraphQL } from "./objectInfoGraphQLService";
+import { queryForObjectInfos, queryForPicklistValues } from "./objectInfoGraphQLService";
 import {
 	graphQLObjectInfosToBatchResponse,
 	extractPicklistValuesFromGraphQLObjectInfo,
@@ -47,7 +47,7 @@ export async function getObjectInfoBatch(objectApiNames: string): Promise<Object
 	if (inFlight) return inFlight;
 	const promise = (async () => {
 		try {
-			const response = await getObjectInfosGraphQL(names);
+			const response = await queryForObjectInfos(names);
 			const nodes = response?.uiapi?.objectInfos ?? [];
 			const result = graphQLObjectInfosToBatchResponse(nodes, names);
 			objectInfoBatchCache.set(key, result);
@@ -79,14 +79,9 @@ export async function getPicklistValues(
 	fieldName: string,
 	recordTypeId: string = "012000000000000AAA",
 ): Promise<PicklistValue[]> {
-	const response = await getObjectInfosGraphQL([objectApiName], {
-		objectInfoInputs: [
-			{
-				apiName: objectApiName,
-				fieldNames: [fieldName],
-			},
-		],
-	});
+	const response = await queryForPicklistValues([
+		{ apiName: objectApiName, fieldNames: [fieldName] },
+	]);
 	const nodes = response?.uiapi?.objectInfos ?? [];
 	const node = nodes[0];
 	if (!node) return [];

package/dist/force-app/main/default/webapplications/appreacttemplateb2x/src/features/global-search/components/detail/UiApiDetailForm.tsx

@@ -75,7 +75,7 @@ export function UiApiDetailForm({
 
 	const objectInfo: ObjectInfo | null = useMemo(() => {
 		if (!metadata?.fields) return null;
-		const apiName = typeof metadata.apiName === "string" ? metadata.apiName : undefined;
+		const apiName = metadata.ApiName;
 		return {
 			apiName,
 			fields: Object.fromEntries(
@@ -83,7 +83,7 @@ export function UiApiDetailForm({
 					name,
 					{
 						compoundFieldName: f.compoundFieldName ?? undefined,
-						dataType: f.dataType,
+						dataType: f.dataType ?? "",
 					},
 				]),
 			),

package/dist/force-app/main/default/webapplications/appreacttemplateb2x/src/features/global-search/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/dist/force-app/main/default/webapplications/appreacttemplateb2x/src/features/global-search/types/filters/picklist.ts

@@ -1,32 +1,6 @@
-import { z } from "zod";
+import type { PicklistValue as GraphQLPicklistValue } from "../objectInfo/objectInfo";
 
-/**
- * Type definitions for picklist value structures
- */
-
-// Zod Schema for Picklist Value
-const PicklistValueSchema = z
-	.object({
-		// 1. Cleanup: Attributes are usually an object, not just 'unknown'
-		attributes: z.record(z.string(), z.unknown()).nullish(),
-		label: z.string(),
-
-		// 2. Precise Typing: 'validFor' is an array of indices (numbers)
-		// pointing to the controlling field's values.
-		validFor: z.array(z.number()).nullish(),
-		value: z.string(),
-
-		// 3. Usability: Added common API fields that are useful for UI logic
-		// (marked optional in case the specific API version omits them)
-		defaultValue: z.boolean().nullish(),
-		active: z.boolean().nullish(),
-	})
-	.passthrough();
-
-/**
- * Single picklist value from the API
- */
-export type PicklistValue = z.infer<typeof PicklistValueSchema>;
-
-// Export schema for validation
-export const PicklistValueArraySchema = z.array(PicklistValueSchema);
+export type PicklistValue = GraphQLPicklistValue & {
+	value: NonNullable<GraphQLPicklistValue["value"]>;
+	label: NonNullable<GraphQLPicklistValue["label"]>;
+};

package/dist/force-app/main/default/webapplications/appreacttemplateb2x/src/features/global-search/types/objectInfo/objectInfo.ts

@@ -1,166 +1,49 @@
-import { z } from "zod";
-
-/**
- * Type definitions and Zod schemas for Object Info Batch API response
- */
-
-// Zod Schema for Child Relationship
-const ChildRelationshipSchema = z.object({
-	childObjectApiName: z.string(),
-	fieldName: z.string(),
-	junctionIdListNames: z.array(z.string()),
-	junctionReferenceTo: z.array(z.string()),
-	relationshipName: z.string(),
-});
-
-// Zod Schema for Reference To Info
-const ReferenceToInfoSchema = z.object({
-	apiName: z.string(),
-	nameFields: z.array(z.string()),
-});
-
-// Zod Schema for Filtered Lookup Info (can be null or object)
-const FilteredLookupInfoSchema = z.record(z.string(), z.unknown()).nullable();
-
-// Zod Schema for Field Definition
-// Using passthrough to allow extra fields that might be present in the API response
-const FieldSchema = z
-	.object({
-		apiName: z.string(),
-		calculated: z.boolean(),
-		compound: z.boolean(),
-		compoundComponentName: z.string().nullable(),
-		compoundFieldName: z.string().nullable(),
-		controllerName: z.string().nullable(),
-		controllingFields: z.array(z.string()),
-		createable: z.boolean(),
-		custom: z.boolean(),
-		dataType: z.string(),
-		defaultValue: z.unknown().nullable(),
-		defaultedOnCreate: z.boolean(),
-		digits: z.number(),
-		externalId: z.boolean(),
-		extraTypeInfo: z.string().nullable(),
-		filterable: z.boolean(),
-		filteredLookupInfo: FilteredLookupInfoSchema,
-		highScaleNumber: z.boolean(),
-		htmlFormatted: z.boolean(),
-		inlineHelpText: z.string().nullable(),
-		label: z.string(),
-		length: z.number(),
-		maskType: z.string().nullable(),
-		nameField: z.boolean(),
-		polymorphicForeignKey: z.boolean(),
-		precision: z.number(),
-		reference: z.boolean(),
-		referenceTargetField: z.string().nullable(),
-		referenceToInfos: z.array(ReferenceToInfoSchema),
-		relationshipName: z.string().nullable(),
-		required: z.boolean(),
-		scale: z.number(),
-		searchPrefilterable: z.boolean(),
-		sortable: z.boolean(),
-		unique: z.boolean(),
-		updateable: z.boolean(),
-	})
-	.passthrough();
-
-// Zod Schema for Record Type Info
-// Using passthrough to allow extra fields that might be present in the API response
-const RecordTypeInfoSchema = z
-	.object({
-		available: z.boolean(),
-		defaultRecordTypeMapping: z.boolean(),
-		master: z.boolean(),
-		name: z.string(),
-		recordTypeId: z.string(),
-	})
-	.passthrough();
-
-// Zod Schema for Theme Info
-const ThemeInfoSchema = z.object({
-	color: z.string(),
-	iconUrl: z.string(),
-});
-
-// Zod Schema for Object Info Result
-// Using passthrough to allow extra fields and using FieldSchema/RecordTypeInfoSchema with passthrough
-const ObjectInfoResultSchema = z
-	.object({
-		apiName: z.string(),
-		associateEntityType: z.string().nullable(),
-		associateParentEntity: z.string().nullable(),
-		childRelationships: z.array(ChildRelationshipSchema),
-		compactLayoutable: z.boolean(),
-		createable: z.boolean(),
-		custom: z.boolean(),
-		defaultRecordTypeId: z.string(),
-		deletable: z.boolean(),
-		dependentFields: z.record(z.string(), z.unknown()),
-		eTag: z.string(),
-		feedEnabled: z.boolean(),
-		// Avoid using FieldSchema because of performance concerns with validating the high number of fields returned from the Salesforce API and causing the UI to freeze.
-		fields: z.record(z.string(), z.any()),
-		keyPrefix: z.string(),
-		label: z.string(),
-		labelPlural: z.string(),
-		layoutable: z.boolean(),
-		mruEnabled: z.boolean(),
-		nameFields: z.array(z.string()),
-		queryable: z.boolean(),
-		// Avoid using RecordTypeInfoSchema because of performance concerns with validating the high number of fields returned from the Salesforce API and causing the UI to freeze.
-		recordTypeInfos: z.record(z.string(), z.any()),
-		searchLayoutable: z.boolean(),
-		searchable: z.boolean(),
-		themeInfo: ThemeInfoSchema,
-		updateable: z.boolean(),
-	})
-	.passthrough();
-
-// Zod Schema for Object Info Batch Result Item
-const ObjectInfoBatchResultItemSchema = z.object({
-	result: ObjectInfoResultSchema,
-	statusCode: z.number(),
-});
-
-// Zod Schema for Object Info Batch Response (array of items)
-export const ObjectInfoBatchResponseSchema = z.object({
-	results: z.array(ObjectInfoBatchResultItemSchema),
-});
-
-// TypeScript Types (inferred from Zod schemas)
-export type ChildRelationship = z.infer<typeof ChildRelationshipSchema>;
-export type ReferenceToInfo = z.infer<typeof ReferenceToInfoSchema>;
-export type FilteredLookupInfo = z.infer<typeof FilteredLookupInfoSchema>;
-export type Field = z.infer<typeof FieldSchema>;
-export type RecordTypeInfo = z.infer<typeof RecordTypeInfoSchema>;
-export type ThemeInfo = z.infer<typeof ThemeInfoSchema>;
-export type ObjectInfoBatchResponse = z.infer<typeof ObjectInfoBatchResponseSchema>;
-// Type Patching: Overwriting the "any" from the performance-optimized schema
-// with the strict types defined above. This ensures Developers get strict typing
-// even though the Runtime Validator skips the deep check.
-export type ObjectInfoResult = Omit<
-	z.infer<typeof ObjectInfoResultSchema>,
-	"fields" | "recordTypeInfos"
-> & {
-	fields: Record<string, Field>;
-	recordTypeInfos: Record<string, RecordTypeInfo>;
+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 ObjectInfoBatchResultItem = Omit<
-	z.infer<typeof ObjectInfoBatchResultItemSchema>,
-	"result"
-> & {
-	result: ObjectInfoResult;
+export type ObjectInfoBatchResponse = {
+	results: { result: ObjectInfoResult; statusCode: number }[];
 };
 
-// Export schemas for validation
-export {
-	ChildRelationshipSchema,
-	ReferenceToInfoSchema,
-	FilteredLookupInfoSchema,
-	FieldSchema,
-	RecordTypeInfoSchema,
-	ThemeInfoSchema,
-	ObjectInfoResultSchema,
-	ObjectInfoBatchResultItemSchema,
-};
+// 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/dist/force-app/main/default/webapplications/appreacttemplateb2x/src/features/global-search/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/dist/force-app/main/default/webapplications/appreacttemplateb2x/src/features/global-search/utils/graphQLObjectInfoAdapter.ts

@@ -10,259 +10,36 @@
 
 import type {
 	ObjectInfoBatchResponse,
+	GetObjectInfosQueryObjectInfos,
+	GetPicklistValuesQueryObjectInfo,
+	GetPicklistValuesQueryField,
+	GetObjectInfosQueryObjectInfo,
 	ObjectInfoResult,
-	Field,
-	RecordTypeInfo,
-	ThemeInfo,
+	PicklistValue as GraphQLPicklistValue,
 } from "../types/objectInfo/objectInfo";
 import type { PicklistValue } from "../types/filters/picklist";
 
-type GraphQLNode = Record<string, unknown>;
-
-function getStr(node: GraphQLNode, key: string): string {
-	const v = node[key] ?? node[key.charAt(0).toLowerCase() + key.slice(1)];
-	return typeof v === "string" ? v : "";
-}
-
-function getNum(node: GraphQLNode, key: string): number {
-	const v = node[key] ?? node[key.charAt(0).toLowerCase() + key.slice(1)];
-	return typeof v === "number" ? v : 0;
-}
-
-function getBool(node: GraphQLNode, key: string): boolean {
-	const v = node[key] ?? node[key.charAt(0).toLowerCase() + key.slice(1)];
-	return typeof v === "boolean" ? v : false;
-}
-
-function getArr<T>(node: GraphQLNode, key: string, map: (item: unknown) => T): T[] {
-	const v = node[key] ?? node[key.charAt(0).toLowerCase() + key.slice(1)];
-	if (!Array.isArray(v)) return [];
-	return v.map((item) => map(item));
-}
-
-function getObj(node: GraphQLNode, key: string): Record<string, unknown> {
-	const v = node[key] ?? node[key.charAt(0).toLowerCase() + key.slice(1)];
-	return v != null && typeof v === "object" && !Array.isArray(v)
-		? (v as Record<string, unknown>)
-		: {};
-}
-
-/** GraphQL returns dependentFields as [DependentField]; REST expects Record. Normalize to object. */
-function toDependentFieldsRecord(v: unknown): Record<string, unknown> {
-	if (v == null) return {};
-	if (Array.isArray(v)) return {};
-	return typeof v === "object" ? (v as Record<string, unknown>) : {};
-}
-
-/** Canonical dataType casing for formatters (Phone, FormattedAddress) and reference resolution (Reference). */
-const DATA_TYPE_CANONICAL: Record<string, string> = {
-	phone: "Phone",
-	email: "Email",
-	url: "Url",
-	address: "Address",
-	reference: "Reference",
-};
-
-function normalizeDataType(raw: string): string {
-	if (!raw) return raw;
-	const lower = raw.toLowerCase();
-	return DATA_TYPE_CANONICAL[lower] ?? raw;
-}
-
-/** Normalize GraphQL Field to our Field type (REST-compatible). */
-function mapField(fieldNode: unknown): [string, Field] {
-	const n = (fieldNode != null && typeof fieldNode === "object" ? fieldNode : {}) as GraphQLNode;
-	const apiName = getStr(n, "ApiName") || getStr(n, "apiName");
-	const label = getStr(n, "label");
-	const dataType = normalizeDataType(getStr(n, "dataType"));
-	const relationshipName = getStr(n, "relationshipName") || null;
-	const reference = getBool(n, "reference");
-	const compound = getBool(n, "compound");
-	const compoundFieldName = getStr(n, "compoundFieldName") || null;
-	const compoundComponentName = getStr(n, "compoundComponentName") || null;
-	const controllingFields = getArr(n, "controllingFields", String);
-	const controllerName = getStr(n, "controllerName") || null;
-	const referenceToInfos = getArr(n, "referenceToInfos", (item) => {
-		const r = (item != null && typeof item === "object" ? item : {}) as GraphQLNode;
-		return {
-			apiName: getStr(r, "apiName") || getStr(r, "ApiName"),
-			nameFields: getArr(r, "nameFields", String),
-		};
-	});
-	return [
-		apiName,
-		{
-			apiName,
-			label,
-			dataType,
-			relationshipName,
-			reference,
-			compound,
-			compoundFieldName,
-			compoundComponentName,
-			controllingFields,
-			controllerName,
-			referenceToInfos,
-			calculated: getBool(n, "calculated"),
-			createable: getBool(n, "createable"),
-			custom: getBool(n, "custom"),
-			defaultValue: n.defaultValue ?? null,
-			defaultedOnCreate: getBool(n, "defaultedOnCreate"),
-			digits: getNum(n, "digits"),
-			externalId: getBool(n, "externalId"),
-			extraTypeInfo: getStr(n, "extraTypeInfo") || null,
-			filterable: getBool(n, "filterable"),
-			filteredLookupInfo: null,
-			highScaleNumber: getBool(n, "highScaleNumber"),
-			htmlFormatted: getBool(n, "htmlFormatted"),
-			inlineHelpText: getStr(n, "inlineHelpText") || null,
-			length: getNum(n, "length"),
-			maskType: getStr(n, "maskType") || null,
-			nameField: getBool(n, "nameField"),
-			polymorphicForeignKey: getBool(n, "polymorphicForeignKey"),
-			precision: getNum(n, "precision"),
-			required: getBool(n, "required"),
-			scale: getNum(n, "scale"),
-			searchPrefilterable: getBool(n, "searchPrefilterable"),
-			sortable: getBool(n, "sortable"),
-			unique: getBool(n, "unique"),
-			updateable: getBool(n, "updateable"),
-			referenceTargetField: getStr(n, "referenceTargetField") || null,
-		} as Field,
-	];
-}
-
-/** Normalize GraphQL recordTypeInfo to RecordTypeInfo. */
-function mapRecordTypeInfo(rtNode: unknown): [string, RecordTypeInfo] {
-	const n = (rtNode != null && typeof rtNode === "object" ? rtNode : {}) as GraphQLNode;
-	const recordTypeId = getStr(n, "recordTypeId");
-	return [
-		recordTypeId,
-		{
-			recordTypeId,
-			name: getStr(n, "name"),
-			master: getBool(n, "master"),
-			available: getBool(n, "available"),
-			defaultRecordTypeMapping: getBool(n, "defaultRecordTypeMapping"),
-		} as RecordTypeInfo,
-	];
-}
-
-function toFieldsMap(fieldsNode: unknown): Record<string, Field> {
-	if (fieldsNode == null) return {};
-	if (Array.isArray(fieldsNode)) {
-		return Object.fromEntries((fieldsNode as unknown[]).map(mapField).filter(([k]) => k));
-	}
-	if (typeof fieldsNode === "object" && !Array.isArray(fieldsNode)) {
-		const entries = Object.entries(fieldsNode as Record<string, unknown>).map(([, v]) =>
-			mapField(v),
-		);
-		return Object.fromEntries(entries.filter(([k]) => k));
-	}
-	return {};
-}
-
-/**
- * Ensures compound parent fields (e.g. BillingAddress, ShippingAddress) exist in the fields map
- * with dataType "Address" so layout transform can set item.dataType for FormattedAddress.
- * GraphQL may only return component fields (BillingStreet, etc.) with compoundFieldName.
- */
-function ensureCompoundParentFields(fields: Record<string, Field>): Record<string, Field> {
-	const result = { ...fields };
-	for (const field of Object.values(fields)) {
-		const compoundName = field.compoundFieldName;
-		if (!compoundName || result[compoundName] != null) continue;
-		const dataType =
-			compoundName.endsWith("Address") || compoundName.endsWith("address") ? "Address" : "String";
-		result[compoundName] = {
-			...field,
-			apiName: compoundName,
-			label: compoundName,
-			dataType,
-			compound: true,
-			compoundFieldName: null,
-			compoundComponentName: null,
-		} as Field;
-	}
-	return result;
-}
-
-function toRecordTypeInfosMap(rtNode: unknown): Record<string, RecordTypeInfo> {
-	if (rtNode == null) return {};
-	if (Array.isArray(rtNode)) {
-		return Object.fromEntries((rtNode as unknown[]).map(mapRecordTypeInfo).filter(([k]) => k));
-	}
-	if (typeof rtNode === "object" && !Array.isArray(rtNode)) {
-		const entries = Object.entries(rtNode as Record<string, unknown>).map(([, v]) =>
-			mapRecordTypeInfo(v),
-		);
-		return Object.fromEntries(entries.filter(([k]) => k));
-	}
-	return {};
-}
-
-/** Map a single GraphQL ObjectInfo node to ObjectInfoResult (REST-compatible). */
-export function graphQLObjectInfoToObjectInfoResult(node: GraphQLNode): ObjectInfoResult {
-	const themeInfoNode = getObj(node, "themeInfo");
-	const themeInfo: ThemeInfo = {
-		color: getStr(themeInfoNode, "color"),
-		iconUrl: getStr(themeInfoNode, "iconUrl"),
-	};
-
-	const childRelationships = getArr(node, "childRelationships", (item) => {
-		const c = (item != null && typeof item === "object" ? item : {}) as GraphQLNode;
-		return {
-			childObjectApiName: getStr(c, "childObjectApiName"),
-			fieldName: getStr(c, "fieldName"),
-			junctionIdListNames: getArr(c, "junctionIdListNames", String),
-			junctionReferenceTo: getArr(c, "junctionReferenceTo", String),
-			relationshipName: getStr(c, "relationshipName"),
-		};
-	});
-
-	const apiName = getStr(node, "ApiName") || getStr(node, "apiName");
-	const fieldsNode = node.fields ?? node.Fields;
-	const recordTypeInfosNode = node.recordTypeInfos ?? node.RecordTypeInfos;
-
+export function graphQLObjectInfoToObjectInfoResult(
+	objectInfo: GetObjectInfosQueryObjectInfo,
+): ObjectInfoResult {
+	const { fields, ...rest } = objectInfo;
+	const fieldsRecord = Object.fromEntries((fields ?? []).map((field) => [field?.ApiName, field]));
 	return {
-		apiName,
-		label: getStr(node, "label"),
-		labelPlural: getStr(node, "labelPlural"),
-		nameFields: getArr(node, "nameFields", String),
-		defaultRecordTypeId: getStr(node, "defaultRecordTypeId") || "012000000000000AAA",
-		keyPrefix: getStr(node, "keyPrefix"),
-		layoutable: getBool(node, "layoutable"),
-		queryable: getBool(node, "queryable"),
-		searchable: getBool(node, "searchable"),
-		updateable: getBool(node, "updateable"),
-		deletable: getBool(node, "deletable"),
-		createable: getBool(node, "createable"),
-		custom: getBool(node, "custom"),
-		mruEnabled: getBool(node, "mruEnabled"),
-		feedEnabled: getBool(node, "feedEnabled"),
-		fields: ensureCompoundParentFields(toFieldsMap(fieldsNode)),
-		recordTypeInfos: toRecordTypeInfosMap(recordTypeInfosNode),
-		themeInfo,
-		childRelationships,
-		associateEntityType: getStr(node, "associateEntityType") || null,
-		associateParentEntity: getStr(node, "associateParentEntity") || null,
-		compactLayoutable: getBool(node, "compactLayoutable"),
-		searchLayoutable: getBool(node, "searchLayoutable"),
-		dependentFields: toDependentFieldsRecord(node.dependentFields ?? node.DependentFields),
-		eTag: getStr(node, "eTag"),
-	} as ObjectInfoResult;
+		...rest,
+		fields: fieldsRecord,
+	};
 }
 
 /** Convert GraphQL objectInfos array to ObjectInfoBatchResponse (REST shape). */
 export function graphQLObjectInfosToBatchResponse(
-	nodes: GraphQLNode[],
+	objectInfos: GetObjectInfosQueryObjectInfos,
 	_requestedApiNames: string[],
 ): ObjectInfoBatchResponse {
-	const results = nodes.map((node) => ({
-		result: graphQLObjectInfoToObjectInfoResult(node),
+	const results = objectInfos.map((objectInfo) => ({
+		result: graphQLObjectInfoToObjectInfoResult(objectInfo!),
 		statusCode: 200,
 	}));
-	return { results } as ObjectInfoBatchResponse;
+	return { results };
 }
 
 /**
@@ -270,50 +47,31 @@ export function graphQLObjectInfosToBatchResponse(
  * Uses picklistValuesByRecordTypeIDs; prefers the given recordTypeId or first available.
  */
 export function extractPicklistValuesFromGraphQLObjectInfo(
-	node: GraphQLNode,
+	objectInfo: NonNullable<GetPicklistValuesQueryObjectInfo>,
 	fieldName: string,
 	recordTypeId?: string,
 ): PicklistValue[] {
-	const fieldsNode = node.fields ?? node.Fields;
-	if (fieldsNode == null || typeof fieldsNode !== "object") return [];
-	const fieldMap = Array.isArray(fieldsNode)
-		? Object.fromEntries(
-				(fieldsNode as unknown[]).map((f: unknown) => {
-					const n = (f != null && typeof f === "object" ? f : {}) as GraphQLNode;
-					const k = getStr(n, "ApiName") || getStr(n, "apiName");
-					return [k, n];
-				}),
-			)
-		: (fieldsNode as Record<string, GraphQLNode>);
+	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 || typeof field !== "object") return [];
-	const picklistData = field.picklistValuesByRecordTypeIDs ?? field.PicklistValuesByRecordTypeIDs;
-	if (!picklistData || !Array.isArray(picklistData)) return [];
+	if (!field) return [];
+	const picklistData =
+		"picklistValuesByRecordTypeIDs" in field ? field.picklistValuesByRecordTypeIDs : undefined;
+	if (!picklistData) return [];
 	const rtId = recordTypeId ?? "012000000000000AAA";
-	const arr = picklistData as Array<Record<string, unknown>>;
-	const byRecordType = arr.find((p) => (p.recordTypeID ?? p.recordTypeId) === rtId);
-	if (!byRecordType) {
-		const first = arr[0];
-		if (!first) return [];
-		return mapPicklistValues(first);
-	}
-	return mapPicklistValues(byRecordType);
+	const byRecordType = picklistData.find((p) => p!.recordTypeID === rtId) ?? picklistData[0];
+	return mapPicklistValues(byRecordType?.picklistValues ?? []);
 }
 
-function mapPicklistValues(byRecordType: Record<string, unknown>): PicklistValue[] {
-	const raw = byRecordType.picklistValues;
-	if (!Array.isArray(raw)) return [];
-	return raw.map((item: unknown) => {
-		const n = (item != null && typeof item === "object" ? item : {}) as Record<string, unknown>;
-		return {
-			label: typeof n.label === "string" ? n.label : "",
-			value: typeof n.value === "string" ? n.value : "",
-			validFor: Array.isArray(n.validFor) ? n.validFor : undefined,
-			attributes: (n.attributes != null && typeof n.attributes === "object"
-				? n.attributes
-				: undefined) as Record<string, unknown> | undefined,
-			defaultValue: typeof n.defaultValue === "boolean" ? n.defaultValue : undefined,
-			active: typeof n.active === "boolean" ? n.active : undefined,
-		} as PicklistValue;
-	});
+function mapPicklistValues(values: GraphQLPicklistValue[]): PicklistValue[] {
+	return values.map((item) => ({
+		...item,
+		value: item.value ?? "",
+		label: item.label ?? "",
+	}));
 }

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

@@ -49,13 +49,13 @@ const getFetchableFieldsFromLayoutItem = function (
 
 		// add field: fieldType
 		const fieldMetadata = metadata.fields[comp.apiName];
-		fields[comp.apiName] = fieldMetadata ? fieldMetadata.dataType : "";
+		fields[comp.apiName] = 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;
+				fields[relationshipName] = fieldMetadata.dataType ?? "";
 
 				relationFieldMap[comp.apiName] = relationshipName;
 			}
@@ -65,7 +65,7 @@ const getFetchableFieldsFromLayoutItem = function (
 			const idField = findIdFieldForRelationship(metadata, comp.apiName);
 			if (idField) {
 				const idMeta = metadata.fields[idField];
-				fields[idField] = idMeta ? idMeta.dataType : "";
+				fields[idField] = idMeta?.dataType ?? "";
 				relationFieldMap[idField] = comp.apiName;
 			}
 		}
@@ -137,7 +137,7 @@ export const calculateFieldsToFetch = function (
 	const fields = getFetchableFieldsFromLayout(metadata, layout, relationFieldMap);
 	let fieldsToFetch = Object.keys(fields);
 	if (shouldPrefixedWithEntityName) {
-		fieldsToFetch = fieldsToFetch.map((field) => `${metadata.apiName}.${field}`);
+		fieldsToFetch = fieldsToFetch.map((field) => `${metadata.ApiName}.${field}`);
 	}
 	// populate field types for o11y logging
 	const fieldTypes = Object.values(fields).filter((fieldType) => fieldType !== "");

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

@@ -87,13 +87,8 @@ export type {
 	FiltersResponse,
 } from "./features/global-search/types/filters/filters";
 
-export { PicklistValueArraySchema } from "./features/global-search/types/filters/picklist";
 export type { PicklistValue } from "./features/global-search/types/filters/picklist";
 
-export {
-	ObjectInfoBatchResponseSchema,
-	ObjectInfoResultSchema,
-} from "./features/global-search/types/objectInfo/objectInfo";
 export type {
 	ObjectInfoBatchResponse,
 	ObjectInfoResult,

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@salesforce/webapp-template-base-sfdx-project-experimental",
-  "version": "1.76.1",
+  "version": "1.77.0",
   "description": "Base SFDX project template",
   "private": true,
   "files": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@salesforce/webapp-template-app-react-template-b2x-experimental",
-  "version": "1.76.1",
+  "version": "1.77.0",
   "description": "Base reference app template",
   "license": "SEE LICENSE IN LICENSE.txt",
   "author": "",