@salesforce/ui-bundle-template-app-angular-template-b2x 11.30.0

package/dist/force-app/main/default/uiBundles/angularexternalapp/src/app/api/account/account-search.service.ts

@@ -0,0 +1,196 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+import { Injectable, inject } from "@angular/core";
+// DataClient is provided by the base-angular-app. Consumed via the
+// `__inherit__` stub one level up (app/api/account/ -> app/api/); post-compose
+// patches-cli strips the prefix so it resolves to the seeded base file at
+// app/api/data-client.service.ts.
+import { DataClient } from "../data-client.service";
+// Query constants are owned by this feature (sibling files) so object-search
+// is self-contained — no external GraphQL dependency.
+import { SEARCH_ACCOUNTS } from "./searchAccounts";
+import { GET_ACCOUNT_DETAIL } from "./getAccountDetail";
+import { DISTINCT_ACCOUNT_INDUSTRIES } from "./distinctAccountIndustries";
+import { DISTINCT_ACCOUNT_TYPES } from "./distinctAccountTypes";
+
+// ---------------------------------------------------------------------------
+// Local response shape types. Codegen is PARKED for the Angular port; when it
+// lands, replace these hand-written interfaces with the generated ones from
+// graphql-operations-types (see the React reference for the equivalent).
+// ---------------------------------------------------------------------------
+
+/** A Salesforce GraphQL scalar field: `{ value, displayValue }`. */
+export interface UiScalarField<T = unknown> {
+	value?: T | null;
+	displayValue?: string | null;
+}
+
+/** An Account node with the fields the search + detail queries request. */
+export interface AccountNode {
+	Id: string;
+	Name?: UiScalarField<string> | null;
+	Industry?: UiScalarField<string> | null;
+	Type?: UiScalarField<string> | null;
+	Phone?: UiScalarField<string> | null;
+	Owner?: { Name?: UiScalarField<string> | null } | null;
+	AnnualRevenue?: UiScalarField<number> | null;
+	// Detail-only fields (undefined in list responses).
+	Fax?: UiScalarField<string> | null;
+	Parent?: { Name?: UiScalarField<string> | null } | null;
+	Website?: UiScalarField<string> | null;
+	NumberOfEmployees?: UiScalarField<number> | null;
+	Description?: UiScalarField<string> | null;
+	BillingStreet?: UiScalarField<string> | null;
+	BillingCity?: UiScalarField<string> | null;
+	BillingState?: UiScalarField<string> | null;
+	BillingPostalCode?: UiScalarField<string> | null;
+	BillingCountry?: UiScalarField<string> | null;
+	ShippingStreet?: UiScalarField<string> | null;
+	ShippingCity?: UiScalarField<string> | null;
+	ShippingState?: UiScalarField<string> | null;
+	ShippingPostalCode?: UiScalarField<string> | null;
+	ShippingCountry?: UiScalarField<string> | null;
+	CreatedBy?: { Name?: UiScalarField<string> | null } | null;
+	CreatedDate?: UiScalarField<string> | null;
+	LastModifiedBy?: { Name?: UiScalarField<string> | null } | null;
+	LastModifiedDate?: UiScalarField<string> | null;
+}
+
+/** GraphQL page-info block returned by the connection response. */
+export interface AccountPageInfo {
+	hasNextPage?: boolean;
+	hasPreviousPage?: boolean;
+	endCursor?: string | null;
+	startCursor?: string | null;
+}
+
+/** The `uiapi.query.Account` connection returned by the search query. */
+export interface AccountSearchResult {
+	edges: Array<{ node: AccountNode } | null> | null;
+	pageInfo: AccountPageInfo;
+	totalCount?: number;
+}
+
+/** Wire shape for the `search` query. */
+interface SearchAccountsData {
+	uiapi: { query: { Account: AccountSearchResult | null } };
+}
+
+/** Wire shape for the `getAccountDetail` query. */
+interface GetAccountDetailData {
+	uiapi: {
+		query: {
+			Account: { edges: Array<{ node: AccountNode } | null> | null } | null;
+		};
+	};
+}
+
+/** Wire shape for the distinct-value aggregate queries. */
+interface DistinctAccountData {
+	uiapi: {
+		aggregate: {
+			Account: {
+				edges: Array<{
+					node: {
+						aggregate?: Record<
+							string,
+							{
+								value?: string | null;
+								displayValue?: string | null;
+								label?: string | null;
+							} | null
+						> | null;
+					};
+				} | null> | null;
+			} | null;
+		};
+	};
+}
+
+/** Picklist option shape shared with filter components. */
+export interface PicklistOption {
+	value: string;
+	label: string;
+}
+
+/** Search args mirroring the React `AccountSearchOptions`. */
+export interface AccountSearchArgs {
+	where?: unknown;
+	orderBy?: unknown;
+	first?: number;
+	after?: string;
+}
+
+/**
+ * Angular account-search data service.
+ *
+ * Wraps the base-app's `DataClient` with typed methods per feature query
+ * (search, detail, and the two distinct-value aggregates that populate the
+ * Industry / Type filter options). Provided in root; the service is stateless
+ * (all state lives in `ObjectSearchStateService` per-page).
+ *
+ * Mirrors the React `accountSearchService` module — the shape of the returned
+ * data is identical so the templates can be a straight JSX-to-Angular port.
+ */
+@Injectable({ providedIn: "root" })
+export class AccountSearchService {
+	private readonly client = inject(DataClient);
+
+	/** Runs the search query and returns the `Account` connection. */
+	async searchAccounts(args: AccountSearchArgs = {}): Promise<AccountSearchResult> {
+		const { where, orderBy, first = 20, after } = args;
+		const data = await this.client.execute<SearchAccountsData, AccountSearchArgs>(SEARCH_ACCOUNTS, {
+			where,
+			orderBy,
+			first,
+			after,
+		});
+		const account = data.uiapi.query.Account;
+		if (!account) {
+			throw new Error("No Account data returned");
+		}
+		return account;
+	}
+
+	/** Fetches a single Account by Id; returns `null` if not found. */
+	async getAccountDetail(id: string): Promise<AccountNode | null> {
+		const data = await this.client.execute<GetAccountDetailData, { id: string }>(
+			GET_ACCOUNT_DETAIL,
+			{ id },
+		);
+		return data.uiapi.query.Account?.edges?.[0]?.node ?? null;
+	}
+
+	/** Distinct `Industry` values for the picklist filter. */
+	async fetchDistinctIndustries(): Promise<PicklistOption[]> {
+		return this.fetchDistinctValues("Industry", DISTINCT_ACCOUNT_INDUSTRIES);
+	}
+
+	/** Distinct `Type` values for the multipicklist filter. */
+	async fetchDistinctTypes(): Promise<PicklistOption[]> {
+		return this.fetchDistinctValues("Type", DISTINCT_ACCOUNT_TYPES);
+	}
+
+	/**
+	 * Shared distinct-value shape parser. Mirrors the React
+	 * `fetchDistinctValues` in `objectSearchService.ts`: pulls
+	 * `uiapi.aggregate.Account.edges[].node.aggregate[fieldName]` and derives a
+	 * `{ value, label }` option, preferring `label` -> `displayValue` -> `value`
+	 * as the display string.
+	 */
+	private async fetchDistinctValues(fieldName: string, query: string): Promise<PicklistOption[]> {
+		const data = await this.client.execute<DistinctAccountData>(query);
+		const edges = data.uiapi.aggregate.Account?.edges ?? [];
+		const options: PicklistOption[] = [];
+		for (const edge of edges) {
+			const field = edge?.node.aggregate?.[fieldName];
+			const value = field?.value;
+			if (!value) continue;
+			options.push({ value, label: field.label ?? field.displayValue ?? value });
+		}
+		return options;
+	}
+}

package/dist/force-app/main/default/uiBundles/angularexternalapp/src/app/api/account/distinctAccountIndustries.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+export const DISTINCT_ACCOUNT_INDUSTRIES = /* GraphQL */ `
+	query DistinctAccountIndustries {
+		uiapi {
+			aggregate {
+				Account(groupBy: { Industry: { group: true } }) {
+					edges {
+						node {
+							aggregate @optional {
+								Industry @optional {
+									value
+									displayValue
+									label
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+`;

package/dist/force-app/main/default/uiBundles/angularexternalapp/src/app/api/account/distinctAccountTypes.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+export const DISTINCT_ACCOUNT_TYPES = /* GraphQL */ `
+	query DistinctAccountTypes {
+		uiapi {
+			aggregate {
+				Account(groupBy: { Type: { group: true } }) {
+					edges {
+						node {
+							aggregate @optional {
+								Type @optional {
+									value
+									displayValue
+									label
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+`;

package/dist/force-app/main/default/uiBundles/angularexternalapp/src/app/api/account/getAccountDetail.ts

@@ -0,0 +1,128 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+export const GET_ACCOUNT_DETAIL = /* GraphQL */ `
+	query GetAccountDetail($id: ID!) {
+		uiapi {
+			query {
+				Account(where: { Id: { eq: $id } }) {
+					edges {
+						node {
+							Id
+							Name @optional {
+								value
+								displayValue
+							}
+							Owner @optional {
+								Name @optional {
+									value
+									displayValue
+								}
+							}
+							Phone @optional {
+								value
+								displayValue
+							}
+							Fax @optional {
+								value
+								displayValue
+							}
+							Parent @optional {
+								Name @optional {
+									value
+									displayValue
+								}
+							}
+							Website @optional {
+								value
+								displayValue
+							}
+							Type @optional {
+								value
+								displayValue
+							}
+							NumberOfEmployees @optional {
+								value
+								displayValue
+							}
+							Industry @optional {
+								value
+								displayValue
+							}
+							AnnualRevenue @optional {
+								value
+								displayValue
+							}
+							Description @optional {
+								value
+								displayValue
+							}
+							BillingStreet @optional {
+								value
+								displayValue
+							}
+							BillingCity @optional {
+								value
+								displayValue
+							}
+							BillingState @optional {
+								value
+								displayValue
+							}
+							BillingPostalCode @optional {
+								value
+								displayValue
+							}
+							BillingCountry @optional {
+								value
+								displayValue
+							}
+							ShippingStreet @optional {
+								value
+								displayValue
+							}
+							ShippingCity @optional {
+								value
+								displayValue
+							}
+							ShippingState @optional {
+								value
+								displayValue
+							}
+							ShippingPostalCode @optional {
+								value
+								displayValue
+							}
+							ShippingCountry @optional {
+								value
+								displayValue
+							}
+							CreatedBy @optional {
+								Name @optional {
+									value
+									displayValue
+								}
+							}
+							CreatedDate @optional {
+								value
+								displayValue
+							}
+							LastModifiedBy @optional {
+								Name @optional {
+									value
+									displayValue
+								}
+							}
+							LastModifiedDate @optional {
+								value
+								displayValue
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+`;

package/dist/force-app/main/default/uiBundles/angularexternalapp/src/app/api/account/searchAccounts.ts

@@ -0,0 +1,58 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+export const SEARCH_ACCOUNTS = /* GraphQL */ `
+	query SearchAccounts(
+		$first: Int
+		$after: String
+		$where: Account_Filter
+		$orderBy: Account_OrderBy
+	) {
+		uiapi {
+			query {
+				Account(first: $first, after: $after, where: $where, orderBy: $orderBy) {
+					edges {
+						node {
+							Id
+							Name @optional {
+								value
+								displayValue
+							}
+							Industry @optional {
+								value
+								displayValue
+							}
+							Type @optional {
+								value
+								displayValue
+							}
+							Phone @optional {
+								value
+								displayValue
+							}
+							Owner @optional {
+								Name @optional {
+									value
+									displayValue
+								}
+							}
+							AnnualRevenue @optional {
+								value
+								displayValue
+							}
+						}
+					}
+					pageInfo {
+						hasNextPage
+						hasPreviousPage
+						endCursor
+						startCursor
+					}
+					totalCount
+				}
+			}
+		}
+	}
+`;

package/dist/force-app/main/default/uiBundles/angularexternalapp/src/app/api/data-client.service.spec.ts

@@ -0,0 +1,184 @@
+import { TestBed } from '@angular/core/testing';
+import { DataClient } from './data-client.service';
+import { createDataSDK } from '@salesforce/platform-sdk';
+
+vi.mock('@salesforce/platform-sdk', () => ({
+	createDataSDK: vi.fn(),
+}));
+
+describe('DataClient', () => {
+	let service: DataClient;
+	let mockGraphqlQuery: ReturnType<typeof vi.fn>;
+	let mockGraphqlMutate: ReturnType<typeof vi.fn>;
+	let mockFetch: ReturnType<typeof vi.fn>;
+
+	beforeEach(async () => {
+		mockGraphqlQuery = vi.fn();
+		mockGraphqlMutate = vi.fn();
+		mockFetch = vi.fn();
+
+		vi.mocked(createDataSDK).mockResolvedValue({
+			graphql: {
+				query: mockGraphqlQuery,
+				mutate: mockGraphqlMutate,
+			},
+			fetch: mockFetch,
+		} as any);
+
+		await TestBed.configureTestingModule({
+			providers: [DataClient],
+		}).compileComponents();
+
+		service = TestBed.inject(DataClient);
+	});
+
+	afterEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it('should create the service', () => {
+		expect(service).toBeTruthy();
+		expect(service).toBeInstanceOf(DataClient);
+	});
+
+	it('should route plain query operations to graphql.query and return result.data', async () => {
+		const operation = 'query { user { id name } }';
+		const expectedData = { user: { id: '123', name: 'Test User' } };
+		mockGraphqlQuery.mockResolvedValue({ data: expectedData });
+
+		const result = await service.execute(operation);
+
+		expect(mockGraphqlQuery).toHaveBeenCalledWith({ query: operation, variables: undefined });
+		expect(mockGraphqlMutate).not.toHaveBeenCalled();
+		expect(result).toEqual(expectedData);
+	});
+
+	it('should route anonymous query operations to graphql.query', async () => {
+		const operation = '{ user { id name } }';
+		const expectedData = { user: { id: '456', name: 'Anonymous User' } };
+		mockGraphqlQuery.mockResolvedValue({ data: expectedData });
+
+		const result = await service.execute(operation);
+
+		expect(mockGraphqlQuery).toHaveBeenCalledWith({ query: operation, variables: undefined });
+		expect(mockGraphqlMutate).not.toHaveBeenCalled();
+		expect(result).toEqual(expectedData);
+	});
+
+	it('should route mutation operations to graphql.mutate', async () => {
+		const operation = 'mutation { updateUser(id: "123", name: "New Name") { id name } }';
+		const expectedData = { updateUser: { id: '123', name: 'New Name' } };
+		mockGraphqlMutate.mockResolvedValue({ data: expectedData });
+
+		const result = await service.execute(operation);
+
+		expect(mockGraphqlMutate).toHaveBeenCalledWith({ mutation: operation, variables: undefined });
+		expect(mockGraphqlQuery).not.toHaveBeenCalled();
+		expect(result).toEqual(expectedData);
+	});
+
+	it('should detect mutation with leading GraphQL comment and route to graphql.mutate', async () => {
+		const operation = '# This is a comment\nmutation { deleteUser(id: "123") { success } }';
+		const expectedData = { deleteUser: { success: true } };
+		mockGraphqlMutate.mockResolvedValue({ data: expectedData });
+
+		const result = await service.execute(operation);
+
+		expect(mockGraphqlMutate).toHaveBeenCalledWith({ mutation: operation, variables: undefined });
+		expect(mockGraphqlQuery).not.toHaveBeenCalled();
+		expect(result).toEqual(expectedData);
+	});
+
+	it('should not treat query as mutation when comment contains "mutation" word', async () => {
+		const operation = '# this is not a mutation, just a query\nquery { user { id } }';
+		const expectedData = { user: { id: '789' } };
+		mockGraphqlQuery.mockResolvedValue({ data: expectedData });
+
+		const result = await service.execute(operation);
+
+		expect(mockGraphqlQuery).toHaveBeenCalledWith({ query: operation, variables: undefined });
+		expect(mockGraphqlMutate).not.toHaveBeenCalled();
+		expect(result).toEqual(expectedData);
+	});
+
+	it('should throw error when result.errors contains errors', async () => {
+		const operation = 'query { user { id } }';
+		mockGraphqlQuery.mockResolvedValue({
+			data: null,
+			errors: [{ message: 'Field not found' }, { message: 'Permission denied' }],
+		});
+
+		await expect(service.execute(operation)).rejects.toThrow(
+			'GraphQL Error: Field not found; Permission denied',
+		);
+	});
+
+	it('should throw error when result.errors contains a single error', async () => {
+		const operation = 'query { user { id } }';
+		mockGraphqlQuery.mockResolvedValue({
+			data: null,
+			errors: [{ message: 'Unauthorized' }],
+		});
+
+		await expect(service.execute(operation)).rejects.toThrow('GraphQL Error: Unauthorized');
+	});
+
+	it('should throw error when result.data is null with no errors', async () => {
+		const operation = 'query { user { id } }';
+		mockGraphqlQuery.mockResolvedValue({ data: null });
+
+		await expect(service.execute(operation)).rejects.toThrow('GraphQL response data is null');
+	});
+
+	it('should pass variables through to graphql.query', async () => {
+		const operation = 'query GetUser($id: ID!) { user(id: $id) { id name } }';
+		const variables = { id: '999' };
+		const expectedData = { user: { id: '999', name: 'Variable User' } };
+		mockGraphqlQuery.mockResolvedValue({ data: expectedData });
+
+		const result = await service.execute(operation, variables);
+
+		expect(mockGraphqlQuery).toHaveBeenCalledWith({ query: operation, variables });
+		expect(result).toEqual(expectedData);
+	});
+
+	it('should pass variables through to graphql.mutate', async () => {
+		const operation =
+			'mutation UpdateUser($id: ID!, $name: String!) { updateUser(id: $id, name: $name) { id name } }';
+		const variables = { id: '888', name: 'Updated Name' };
+		const expectedData = { updateUser: { id: '888', name: 'Updated Name' } };
+		mockGraphqlMutate.mockResolvedValue({ data: expectedData });
+
+		const result = await service.execute(operation, variables);
+
+		expect(mockGraphqlMutate).toHaveBeenCalledWith({ mutation: operation, variables });
+		expect(result).toEqual(expectedData);
+	});
+
+	it('should proxy fetch to sdk.fetch and return the raw Response', async () => {
+		const url = '/services/apexrest/auth/login';
+		const init: RequestInit = {
+			method: 'POST',
+			body: JSON.stringify({ email: 'a@b.com' }),
+			headers: { 'Content-Type': 'application/json' },
+		};
+		const expectedResponse = { ok: true, status: 200 } as Response;
+		mockFetch.mockResolvedValue(expectedResponse);
+
+		const response = await service.fetch(url, init);
+
+		expect(mockFetch).toHaveBeenCalledWith(url, init);
+		expect(response).toBe(expectedResponse);
+	});
+
+	it('should call fetch with no init when omitted', async () => {
+		const url = '/services/data/v64.0/chatter/users/me';
+		const expectedResponse = { ok: true, status: 200 } as Response;
+		mockFetch.mockResolvedValue(expectedResponse);
+
+		const response = await service.fetch(url);
+
+		expect(mockFetch).toHaveBeenCalledWith(url, undefined);
+		expect(response).toBe(expectedResponse);
+	});
+});

package/dist/force-app/main/default/uiBundles/angularexternalapp/src/app/api/data-client.service.ts

@@ -0,0 +1,74 @@
+import { Injectable } from '@angular/core';
+import { createDataSDK } from '@salesforce/platform-sdk';
+
+/**
+ * True when the operation's first definition is a `mutation`. Strips GraphQL
+ * comments first so a leading `# ...` line can't mask the keyword. Queries
+ * (named or anonymous `{ ... }` shorthand) and subscriptions fall through to
+ * query().
+ */
+function isMutation(operation: string): boolean {
+	return /^\s*mutation\b/.test(operation.replace(/#[^\n\r]*/g, ''));
+}
+
+/**
+ * The single data-access client for the app — a thin wrapper over
+ * `createDataSDK` that centralizes both of the SDK's surfaces:
+ *
+ * - `execute()` for GraphQL (routes mutations to `sdk.graphql.mutate` and
+ *   everything else to `sdk.graphql.query`, with centralized error handling).
+ *   Use with gql-tagged queries and generated operation types for type-safe
+ *   calls.
+ * - `fetch()` for REST (proxies `sdk.fetch`, returning the raw `Response` so
+ *   callers keep full control over response parsing / error shaping).
+ *
+ * Consumers inject this instead of calling `createDataSDK` directly, so the SDK
+ * bootstrap lives in exactly one place. Feature packages consume it via an
+ * `__inherit__data-client.service` stub (base wins at compose).
+ */
+@Injectable({ providedIn: 'root' })
+export class DataClient {
+	/**
+	 * Executes a GraphQL operation and returns its `data`, throwing on GraphQL
+	 * errors or a null payload.
+	 */
+	async execute<TData, TVariables = Record<string, unknown>>(
+		operation: string,
+		variables?: TVariables,
+	): Promise<TData> {
+		const data = await createDataSDK();
+		const result = isMutation(operation)
+			? await data.graphql!.mutate<TData, TVariables>({
+					mutation: operation,
+					variables,
+				})
+			: await data.graphql!.query<TData, TVariables>({
+					query: operation,
+					variables,
+				});
+
+		if (result.errors?.length) {
+			const msg = result.errors.map((e) => e.message).join('; ');
+			throw new Error(`GraphQL Error: ${msg}`);
+		}
+
+		if (result.data == null) {
+			throw new Error('GraphQL response data is null');
+		}
+
+		return result.data;
+	}
+
+	/**
+	 * Performs a REST request through the SDK's authenticated `fetch`, returning
+	 * the raw `Response`. Callers parse the body / shape errors themselves (e.g.
+	 * via `handleApiResponse`).
+	 *
+	 * @param input - The request URL (e.g. an Apex REST route).
+	 * @param init  - Standard `fetch` options (method, headers, body, …).
+	 */
+	async fetch(input: string, init?: RequestInit): Promise<Response> {
+		const sdk = await createDataSDK();
+		return sdk.fetch!(input, init);
+	}
+}