@salesforce/templates 66.3.2 → 66.4.0

package/lib/templates/project/reactb2e/force-app/main/default/webapplications/appreacttemplateb2e/src/features/global-search/hooks/index.ts

@@ -1,22 +0,0 @@
-// ---------------------------------------------------------------------------
-// Hooks
-// ---------------------------------------------------------------------------
-export {
-	useObjectColumns,
-	useObjectSearchResults,
-	useObjectFilters,
-	useObjectListMetadata,
-} from "./useObjectSearchData";
-export type { ObjectListMetadata } from "./useObjectSearchData";
-export { useRecordListGraphQL } from "./useRecordListGraphQL";
-export type {
-	UseRecordListGraphQLReturn,
-	UseRecordListGraphQLOptions,
-} from "./useRecordListGraphQL";
-export { useRecordDetailLayout } from "./useRecordDetailLayout";
-export type {
-	UseRecordDetailLayoutReturn,
-	UseRecordDetailLayoutParams,
-} from "./useRecordDetailLayout";
-export { useObjectInfoBatch } from "./useObjectInfoBatch";
-export type { UseObjectInfoBatchResult } from "./useObjectInfoBatch";

package/lib/templates/project/reactb2e/force-app/main/default/webapplications/appreacttemplateb2e/src/features/global-search/hooks/useObjectSearchData.ts

@@ -1,395 +0,0 @@
-/**
- * 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, useRef, useMemo } from "react";
-import { objectInfoService, type SearchParams } from "../api/objectInfoService";
-import type {
-	Column,
-	SearchResultRecord,
-	SearchResultRecordData,
-} from "../types/search/searchResults";
-import type { Filter, FilterCriteria } from "../types/filters/filters";
-import type { PicklistValue } from "../types/filters/picklist";
-import { createFiltersKey } from "../utils/cacheUtils";
-
-// --- Shared filters cache (deduplicates getObjectListFilters across useObjectColumns + useObjectFilters) ---
-const sharedFiltersCache = new Map<string, Filter[]>();
-const sharedFiltersInFlight = new Map<string, Promise<Filter[]>>();
-
-/**
- * Returns filters for the object, deduplicating the API call across hook instances.
- * Does not pass abort signal to the API so the shared request is not aborted when
- * one consumer's effect cleans up (e.g. React Strict Mode); callers still guard with isCancelled.
- */
-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 ac = new AbortController();
-
-		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, undefined, ac.signal)
-						.then((values) => ({ fieldPath: f.targetFieldPath, values }))
-						.catch((err) => {
-							if (err?.name === "AbortError") throw err;
-							return { 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 || (err instanceof Error && err.name === "AbortError")) return;
-				setState((s) => ({
-					...s,
-					columns: [],
-					filters: [],
-					picklistValues: {},
-					loading: false,
-					error: "Failed to load list metadata",
-				}));
-			}
-		};
-
-		run();
-		return () => {
-			isCancelled = true;
-			ac.abort();
-		};
-	}, [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: useObjectSearchResults
- *
- * Fetches search results for a specific object based on the provided query parameters.
- * Maintains the *latest* result set for the object in state to prevent redundant
- * network requests when the component re-renders with the same parameters.
- * Includes debouncing for search queries (but not pagination).
- *
- * @param objectApiName - The API name of the object to search
- * @param searchQuery - The search query string
- * @param searchPageSize - Number of results per page (default: 50)
- * @param searchPageToken - Pagination token (default: '0')
- * @param filters - Array of filter criteria to apply (default: [])
- * @param sortBy - Sort field and direction (default: 'relevance')
- * @returns Object containing results array, pagination tokens, loading state, and error state
- *
- * @example
- * ```tsx
- * const { results, nextPageToken, previousPageToken, currentPageToken, resultsLoading, resultsError } = useObjectSearchResults(
- *   'Account',
- *   'test query',
- *   25,
- *   '0',
- *   [{ objectApiName: 'Account', fieldPath: 'Name', operator: 'contains', values: ['test'] }]
- * );
- * ```
- */
-export function useObjectSearchResults(
-	objectApiName: string | null,
-	searchQuery: string,
-	searchPageSize: number = 50,
-	searchPageToken: string = "0",
-	filters: FilterCriteria[] = [],
-	sortBy: string = "relevance",
-) {
-	const [resultsCache, setResultsCache] = useState<
-		Record<
-			string,
-			{
-				results: SearchResultRecord[];
-				query: string;
-				pageToken: string;
-				pageSize: number;
-				filtersKey: string;
-				sortBy: string;
-				nextPageToken: string | null;
-				previousPageToken: string | null;
-				currentPageToken: string;
-			}
-		>
-	>({});
-	const [loading, setLoading] = useState<Record<string, boolean>>({});
-	const [error, setError] = useState<Record<string, string | null>>({});
-
-	const debounceTimeout = useRef<ReturnType<typeof setTimeout> | null>(null);
-	const abortControllerRef = useRef<AbortController | null>(null);
-	const resultsCacheRef = useRef(resultsCache);
-
-	const filtersKey = useMemo(() => {
-		const filtersArray = Array.isArray(filters) ? filters : [];
-		return createFiltersKey(filtersArray);
-	}, [filters]);
-
-	useEffect(() => {
-		resultsCacheRef.current = resultsCache;
-	}, [resultsCache]);
-
-	useEffect(() => {
-		if (!objectApiName || !searchQuery.trim()) {
-			return;
-		}
-
-		let isCancelled = false;
-		const abortController = new AbortController();
-
-		if (abortControllerRef.current) {
-			abortControllerRef.current.abort();
-		}
-		abortControllerRef.current = abortController;
-
-		if (debounceTimeout.current) {
-			clearTimeout(debounceTimeout.current);
-			debounceTimeout.current = null;
-		}
-
-		const cached = resultsCacheRef.current[objectApiName];
-		if (
-			!abortController.signal.aborted &&
-			cached &&
-			cached.query === searchQuery &&
-			cached.pageToken === searchPageToken &&
-			cached.pageSize === searchPageSize &&
-			cached.filtersKey === filtersKey &&
-			cached.sortBy === sortBy
-		) {
-			return;
-		}
-
-		if (abortController.signal.aborted) {
-			return;
-		}
-
-		const fetchResults = async () => {
-			setLoading((prev) => ({ ...prev, [objectApiName]: true }));
-			setError((prev) => ({ ...prev, [objectApiName]: null }));
-
-			try {
-				const searchParams: SearchParams = {
-					sortBy: sortBy === "relevance" ? "" : sortBy,
-					filters: filters,
-					pageSize: searchPageSize,
-					pageToken: searchPageToken,
-				};
-
-				const keywordSearchResult = await objectInfoService.searchResults(
-					searchQuery,
-					objectApiName,
-					searchParams,
-					abortController.signal,
-				);
-
-				if (isCancelled || abortController.signal.aborted) return;
-
-				const normalizedRecords = keywordSearchResult.records.map((r) => ({
-					record: r.record as SearchResultRecordData,
-					highlightInfo: r.highlightInfo,
-					searchInfo: r.searchInfo,
-				}));
-
-				const nextPageToken: string | null = keywordSearchResult.nextPageToken ?? null;
-				const previousPageToken: string | null = keywordSearchResult.previousPageToken ?? null;
-
-				setResultsCache((prev): typeof prev => ({
-					...prev,
-					[objectApiName]: {
-						results: normalizedRecords,
-						query: searchQuery,
-						pageToken: searchPageToken,
-						pageSize: searchPageSize,
-						filtersKey: filtersKey,
-						sortBy,
-						nextPageToken,
-						previousPageToken,
-						currentPageToken: keywordSearchResult.currentPageToken,
-					},
-				}));
-			} catch (err) {
-				if (isCancelled || (err instanceof Error && err.name === "AbortError")) {
-					return;
-				}
-				setError((prev) => ({ ...prev, [objectApiName]: "Unable to load search results" }));
-				// Cache empty result so we skip refetch on remount (avoid infinite loop on API error)
-				setResultsCache((prev) => ({
-					...prev,
-					[objectApiName]: {
-						results: [],
-						query: searchQuery,
-						pageToken: searchPageToken,
-						pageSize: searchPageSize,
-						filtersKey: filtersKey,
-						sortBy,
-						nextPageToken: null,
-						previousPageToken: null,
-						currentPageToken: searchPageToken,
-					},
-				}));
-			} finally {
-				if (!isCancelled) {
-					setLoading((prev) => ({ ...prev, [objectApiName]: false }));
-				}
-			}
-		};
-
-		if (searchPageToken === "0") {
-			debounceTimeout.current = setTimeout(() => {
-				fetchResults();
-			}, 300);
-		} else {
-			fetchResults();
-		}
-
-		return () => {
-			isCancelled = true;
-			abortController.abort();
-			if (debounceTimeout.current) {
-				clearTimeout(debounceTimeout.current);
-				debounceTimeout.current = null;
-			}
-			if (abortControllerRef.current === abortController) {
-				abortControllerRef.current = null;
-			}
-		};
-	}, [objectApiName, searchQuery, searchPageSize, searchPageToken, filtersKey, sortBy]);
-
-	return {
-		results: objectApiName ? resultsCache[objectApiName]?.results || [] : [],
-		nextPageToken: objectApiName ? resultsCache[objectApiName]?.nextPageToken || null : null,
-		previousPageToken: objectApiName
-			? resultsCache[objectApiName]?.previousPageToken || null
-			: null,
-		currentPageToken: objectApiName ? resultsCache[objectApiName]?.currentPageToken || "0" : "0",
-		resultsLoading: objectApiName ? loading[objectApiName] || false : false,
-		resultsError: objectApiName ? error[objectApiName] || null : null,
-	};
-}
-
-/**
- * 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/types/filters/picklist.ts

@@ -1,32 +0,0 @@
-import { z } from "zod";
-
-/**
- * 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);

package/lib/templates/project/reactb2e/force-app/main/default/webapplications/appreacttemplateb2e/src/features/global-search/types/index.ts

@@ -1,4 +0,0 @@
-export * from "./filters/filters";
-export * from "./objectInfo/objectInfo";
-export * from "./recordDetail/recordDetail";
-export * from "./search/searchResults";

package/lib/templates/project/reactb2e/force-app/main/default/webapplications/appreacttemplateb2e/src/features/global-search/types/objectInfo/objectInfo.ts

@@ -1,166 +0,0 @@
-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>;
-};
-export type ObjectInfoBatchResultItem = Omit<
-	z.infer<typeof ObjectInfoBatchResultItemSchema>,
-	"result"
-> & {
-	result: ObjectInfoResult;
-};
-
-// Export schemas for validation
-export {
-	ChildRelationshipSchema,
-	ReferenceToInfoSchema,
-	FilteredLookupInfoSchema,
-	FieldSchema,
-	RecordTypeInfoSchema,
-	ThemeInfoSchema,
-	ObjectInfoResultSchema,
-	ObjectInfoBatchResultItemSchema,
-};