@salesforce/ui-bundle-template-app-react-sample-b2e 11.55.0 → 11.56.0

package/dist/force-app/main/default/uiBundles/propertymanagementapp/src/features/search/adapters/cms/__tests__/contentTypeSessionCache.test.ts

@@ -0,0 +1,114 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+/**
+ * Tests for the sessionStorage-backed content-type cache: per-channel type
+ * persistence with FQN re-validation, and the per-UIBundle last-channel pointer
+ * (which must NOT be shared origin-wide, so a second bundle in the same session
+ * never inherits the first bundle's channel). Also covers the degrade-to-null
+ * behavior on corrupt JSON and malformed ids.
+ */
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+// The module transitively imports `searchChannel.ts` (for UI_BUNDLE_ID_PATTERN),
+// which pulls in the platform SDK. Stub it so vite doesn't resolve SDK internals
+// under jsdom — this test never calls into the SDK.
+vi.mock("@salesforce/platform-sdk", () => ({
+	getCurrentApp: vi.fn(() => ({ identity: { bundleId: "" } })),
+}));
+
+import {
+	readCachedContentTypes,
+	writeCachedContentTypes,
+	readLastChannelId,
+	writeLastChannelId,
+} from "../contentTypeSessionCache";
+import type { DiscoveredContentType } from "../contentTypeUtils";
+
+const CHANNEL_A = "0ap000000000001";
+const CHANNEL_B = "0ap000000000002";
+const BUNDLE_A = "9YE000000000001";
+const BUNDLE_B = "9YE000000000002";
+
+const TYPES: DiscoveredContentType[] = [
+	{ fqn: "sfdc_cms__news", label: "News" },
+	{ fqn: "sfdc_cms__blog", label: "Blog" },
+];
+
+describe("contentTypeSessionCache", () => {
+	beforeEach(() => {
+		sessionStorage.clear();
+	});
+
+	describe("content types (keyed by channel)", () => {
+		it("round-trips validated types for a channel", () => {
+			writeCachedContentTypes(CHANNEL_A, TYPES);
+			expect(readCachedContentTypes(CHANNEL_A)).toEqual(TYPES);
+		});
+
+		it("returns null for a channel that was never written", () => {
+			expect(readCachedContentTypes(CHANNEL_A)).toBeNull();
+		});
+
+		it("does not write under a malformed channel id", () => {
+			writeCachedContentTypes("not-a-channel", TYPES);
+			expect(readCachedContentTypes("not-a-channel")).toBeNull();
+		});
+
+		it("drops entries with an invalid FQN on read (untrusted cache)", () => {
+			sessionStorage.setItem(
+				`cms-search:content-types:types:${CHANNEL_A}`,
+				JSON.stringify([
+					{ fqn: "sfdc_cms__ok", label: "Ok" },
+					{ fqn: "evil!!", label: "Bad" },
+				]),
+			);
+			expect(readCachedContentTypes(CHANNEL_A)).toEqual([{ fqn: "sfdc_cms__ok", label: "Ok" }]);
+		});
+
+		it("degrades to null on corrupt JSON", () => {
+			sessionStorage.setItem(`cms-search:content-types:types:${CHANNEL_A}`, "{not json");
+			expect(readCachedContentTypes(CHANNEL_A)).toBeNull();
+		});
+	});
+
+	describe("last channel pointer (keyed by UIBundle)", () => {
+		it("round-trips the last channel for a bundle", () => {
+			writeLastChannelId(BUNDLE_A, CHANNEL_A);
+			expect(readLastChannelId(BUNDLE_A)).toBe(CHANNEL_A);
+		});
+
+		it("isolates the pointer per UIBundle — a second bundle never inherits the first", () => {
+			writeLastChannelId(BUNDLE_A, CHANNEL_A);
+			// A different bundle opened in the same session has no pointer yet.
+			expect(readLastChannelId(BUNDLE_B)).toBeNull();
+			// And writing B does not clobber A.
+			writeLastChannelId(BUNDLE_B, CHANNEL_B);
+			expect(readLastChannelId(BUNDLE_A)).toBe(CHANNEL_A);
+			expect(readLastChannelId(BUNDLE_B)).toBe(CHANNEL_B);
+		});
+
+		it("writeCachedContentTypes does NOT set any last-channel pointer", () => {
+			writeCachedContentTypes(CHANNEL_A, TYPES);
+			expect(readLastChannelId(BUNDLE_A)).toBeNull();
+		});
+
+		it("does not write under a malformed UIBundle id", () => {
+			writeLastChannelId("not-a-bundle", CHANNEL_A);
+			expect(readLastChannelId("not-a-bundle")).toBeNull();
+		});
+
+		it("does not write under a malformed channel id", () => {
+			writeLastChannelId(BUNDLE_A, "not-a-channel");
+			expect(readLastChannelId(BUNDLE_A)).toBeNull();
+		});
+
+		it("returns null when the stored channel shape is invalid", () => {
+			sessionStorage.setItem(`cms-search:content-types:last-channel-id:${BUNDLE_A}`, "garbage");
+			expect(readLastChannelId(BUNDLE_A)).toBeNull();
+		});
+	});
+});

package/dist/force-app/main/default/uiBundles/propertymanagementapp/src/features/search/adapters/cms/__tests__/contentTypeUtils.test.ts

@@ -0,0 +1,82 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+/**
+ * Tests for contentTypeUtils — CMS content type formatting and validation.
+ * Ported from the CMS reference (`…/global-search/utils/__tests__/contentTypeUtils.test.ts`).
+ */
+import { describe, it, expect } from "vitest";
+import { formatContentTypeLabel, isValidCmsFqn, CMS_FQN_PATTERN } from "../contentTypeUtils";
+
+describe("contentTypeUtils", () => {
+	describe("formatContentTypeLabel", () => {
+		it("formats single-word FQN by capitalizing first letter", () => {
+			expect(formatContentTypeLabel("sfdc_cms__news")).toBe("News");
+			expect(formatContentTypeLabel("sfdc_cms__document")).toBe("Document");
+			expect(formatContentTypeLabel("sfdc_cms__image")).toBe("Image");
+		});
+
+		it("formats camelCase FQN by splitting words and title-casing", () => {
+			expect(formatContentTypeLabel("sfdc_cms__blogPost")).toBe("Blog Post");
+			expect(formatContentTypeLabel("sfdc_cms__pressRelease")).toBe("Press Release");
+			expect(formatContentTypeLabel("sfdc_cms__knowledgeArticle")).toBe("Knowledge Article");
+		});
+
+		it("handles multiple camelCase words correctly", () => {
+			expect(formatContentTypeLabel("sfdc_cms__productCatalogItem")).toBe("Product Catalog Item");
+			expect(formatContentTypeLabel("sfdc_cms__videoContentAsset")).toBe("Video Content Asset");
+		});
+
+		it("handles edge cases gracefully", () => {
+			expect(formatContentTypeLabel("news")).toBe("News");
+			expect(formatContentTypeLabel("sfdc_cms__all_lowercase")).toBe("All_lowercase");
+		});
+	});
+
+	describe("isValidCmsFqn", () => {
+		it("returns true for valid CMS FQNs", () => {
+			expect(isValidCmsFqn("sfdc_cms__news")).toBe(true);
+			expect(isValidCmsFqn("sfdc_cms__blogPost")).toBe(true);
+			expect(isValidCmsFqn("sfdc_cms__document")).toBe(true);
+			expect(isValidCmsFqn("sfdc_cms__a")).toBe(true);
+			expect(isValidCmsFqn("sfdc_cms__a123456789012345678901234567890123456789")).toBe(true);
+		});
+
+		it("returns false for FQNs without correct prefix", () => {
+			expect(isValidCmsFqn("news")).toBe(false);
+			expect(isValidCmsFqn("cms__news")).toBe(false);
+			expect(isValidCmsFqn("sfdc_news")).toBe(false);
+		});
+
+		it("returns false for FQNs with invalid characters", () => {
+			expect(isValidCmsFqn("sfdc_cms__news-article")).toBe(false);
+			expect(isValidCmsFqn("sfdc_cms__news article")).toBe(false);
+			expect(isValidCmsFqn("sfdc_cms__news@item")).toBe(false);
+			expect(isValidCmsFqn("sfdc_cms__news_item")).toBe(false);
+		});
+
+		it("returns false for overly long FQNs", () => {
+			expect(isValidCmsFqn("sfdc_cms__a1234567890123456789012345678901234567890")).toBe(false);
+		});
+
+		it("returns false for empty or malformed strings", () => {
+			expect(isValidCmsFqn("")).toBe(false);
+			expect(isValidCmsFqn("sfdc_cms__")).toBe(false);
+			expect(isValidCmsFqn("sfdc_cms__1starts_with_digit")).toBe(false);
+		});
+	});
+
+	describe("CMS_FQN_PATTERN", () => {
+		it("is a RegExp instance", () => {
+			expect(CMS_FQN_PATTERN).toBeInstanceOf(RegExp);
+		});
+
+		it("matches the expected pattern structure", () => {
+			expect(CMS_FQN_PATTERN.source).toContain("sfdc_cms__");
+			expect(CMS_FQN_PATTERN.source).toContain("[a-zA-Z]");
+		});
+	});
+});

package/dist/force-app/main/default/uiBundles/propertymanagementapp/src/features/search/adapters/cms/__tests__/orgApiVersionService.test.ts

@@ -0,0 +1,57 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+/** Tests for the CMS build-version gate. */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { getOrgSupportsCmsSearch, MIN_CMS_API_VERSION } from "../api/orgApiVersionService";
+
+// The build-time API version is compiled in via `__SF_API_VERSION__`; mock it so
+// tests control the gate independently of the environment.
+vi.mock("../api/apiUtils", () => ({
+	getBuildApiVersion: vi.fn(() => 68),
+}));
+
+const { getBuildApiVersion } = await import("../api/apiUtils");
+
+describe("orgApiVersionService", () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+		// Default: a build new enough to pass the gate.
+		vi.mocked(getBuildApiVersion).mockReturnValue(68);
+	});
+
+	it("MIN_CMS_API_VERSION is 68 (core 264)", () => {
+		expect(MIN_CMS_API_VERSION).toBe(68);
+	});
+
+	it("returns true when the build version is exactly the floor (68)", async () => {
+		vi.mocked(getBuildApiVersion).mockReturnValue(68);
+		expect(await getOrgSupportsCmsSearch()).toBe(true);
+	});
+
+	it("returns true when the build version is above the floor (69)", async () => {
+		vi.mocked(getBuildApiVersion).mockReturnValue(69);
+		expect(await getOrgSupportsCmsSearch()).toBe(true);
+	});
+
+	it("returns false when the build version is below the floor (e.g. 67)", async () => {
+		vi.mocked(getBuildApiVersion).mockReturnValue(67);
+		expect(await getOrgSupportsCmsSearch()).toBe(false);
+	});
+
+	it("returns false when the build version is unparseable (0)", async () => {
+		vi.mocked(getBuildApiVersion).mockReturnValue(0);
+		expect(await getOrgSupportsCmsSearch()).toBe(false);
+	});
+
+	it("makes no network call — the gate is purely the build version", async () => {
+		// getBuildApiVersion is the only dependency; there is nothing else to spy on.
+		// A single call resolves the gate.
+		vi.mocked(getBuildApiVersion).mockReturnValue(69);
+		await getOrgSupportsCmsSearch();
+		expect(getBuildApiVersion).toHaveBeenCalledTimes(1);
+	});
+});

package/dist/force-app/main/default/uiBundles/propertymanagementapp/src/features/search/adapters/cms/__tests__/parseResponse.test.ts

@@ -0,0 +1,102 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+/**
+ * Tests for the CMS parseResponse — offset → pageInfo math and partial-failure
+ * leniency (absent subtree → null, never throws).
+ */
+import { describe, it, expect } from "vitest";
+import { parseCmsResponse } from "../parseResponse";
+import type { CmsSourceConfig } from "../types";
+import type { SourceRequest } from "../../types";
+
+const source: CmsSourceConfig = { kind: "cms", key: "content", label: "Content" };
+
+function req(pageSize: number): SourceRequest<CmsSourceConfig> {
+	return { source, q: "hello", filters: [], sort: null, pageSize, afterCursor: undefined };
+}
+
+function makeItems(n: number) {
+	return Array.from({ length: n }, (_, i) => ({
+		managedContentId: `id-${i}`,
+		managedContentKey: `key-${i}`,
+		title: `Item ${i}`,
+		contentType: "sfdc_cms__news",
+		managedContentChannelDeliveryDetails: [],
+	}));
+}
+
+function root(payload: unknown): Record<string, unknown> {
+	return { managed_content: { search: { searchContentInChannels: payload } } };
+}
+
+describe("parseCmsResponse", () => {
+	it("first full page: hasNextPage true, hasPreviousPage false", () => {
+		const result = parseCmsResponse(
+			root({ total: 100, offset: 0, pageSize: 20, items: makeItems(20) }),
+			req(20),
+		);
+		expect(result).not.toBeNull();
+		expect(result!.nodes).toHaveLength(20);
+		expect(result!.totalCount).toBe(100);
+		expect(result!.pageInfo).toEqual({
+			hasNextPage: true,
+			hasPreviousPage: false,
+			startCursor: "0",
+			endCursor: "20",
+		});
+	});
+
+	it("middle page: both next and previous true, cursors advance by pageSize", () => {
+		const result = parseCmsResponse(
+			root({ total: 100, offset: 20, pageSize: 20, items: makeItems(20) }),
+			req(20),
+		);
+		expect(result!.pageInfo).toEqual({
+			hasNextPage: true,
+			hasPreviousPage: true,
+			startCursor: "20",
+			endCursor: "40",
+		});
+	});
+
+	it("last partial page: hasNextPage false", () => {
+		const result = parseCmsResponse(
+			root({ total: 100, offset: 80, pageSize: 20, items: makeItems(20) }),
+			req(20),
+		);
+		expect(result!.pageInfo!.hasNextPage).toBe(false);
+		expect(result!.pageInfo!.hasPreviousPage).toBe(true);
+		expect(result!.pageInfo!.startCursor).toBe("80");
+		expect(result!.pageInfo!.endCursor).toBe("100");
+	});
+
+	it("empty result: zero nodes, no next/previous", () => {
+		const result = parseCmsResponse(
+			root({ total: 0, offset: 0, pageSize: 20, items: [] }),
+			req(20),
+		);
+		expect(result!.nodes).toHaveLength(0);
+		expect(result!.totalCount).toBe(0);
+		expect(result!.pageInfo).toEqual({
+			hasNextPage: false,
+			hasPreviousPage: false,
+			startCursor: "0",
+			endCursor: "20",
+		});
+	});
+
+	it("returns null when the managed_content subtree is absent", () => {
+		expect(parseCmsResponse({}, req(20))).toBeNull();
+		expect(parseCmsResponse({ managed_content: {} }, req(20))).toBeNull();
+		expect(parseCmsResponse({ managed_content: { search: {} } }, req(20))).toBeNull();
+	});
+
+	it("returns null (does not throw) when the subtree is null/errored", () => {
+		expect(() => parseCmsResponse(root(null), req(20))).not.toThrow();
+		expect(parseCmsResponse(root(null), req(20))).toBeNull();
+	});
+});

package/dist/force-app/main/default/uiBundles/propertymanagementapp/src/features/search/adapters/cms/__tests__/searchChannel.test.ts

@@ -0,0 +1,98 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+/** Tests for searchChannel UIBundle id resolution and validation. */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { getUIBundleId, isConfiguredUIBundleId } from "../searchChannel";
+import type { CurrentApp } from "@salesforce/platform-sdk";
+
+vi.mock("@salesforce/platform-sdk", () => ({
+	getCurrentApp: vi.fn(),
+}));
+
+const { getCurrentApp } = await import("@salesforce/platform-sdk");
+
+describe("searchChannel", () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
+
+	describe("getUIBundleId", () => {
+		it("returns bundleId when available in hosted environment", async () => {
+			const mockApp: CurrentApp = {
+				identity: {
+					namespace: "MyNs",
+					appName: "MyBundle",
+					qualifiedName: "MyNs__MyBundle",
+					bundleId: "0apSG000002dvWjYAI",
+				},
+			};
+			vi.mocked(getCurrentApp).mockResolvedValue(mockApp);
+
+			const result = await getUIBundleId();
+
+			expect(result).toBe("0apSG000002dvWjYAI");
+		});
+
+		it("returns empty string when bundleId is undefined", async () => {
+			const mockApp: CurrentApp = {
+				identity: {
+					namespace: "c",
+					appName: "LocalApp",
+					qualifiedName: "c__LocalApp",
+				},
+			};
+			vi.mocked(getCurrentApp).mockResolvedValue(mockApp);
+
+			const result = await getUIBundleId();
+
+			expect(result).toBe("");
+		});
+
+		it("returns empty string when identity is undefined", async () => {
+			const mockApp: CurrentApp = {};
+			vi.mocked(getCurrentApp).mockResolvedValue(mockApp);
+
+			const result = await getUIBundleId();
+
+			expect(result).toBe("");
+		});
+
+		it("returns empty string when getCurrentApp returns empty object", async () => {
+			vi.mocked(getCurrentApp).mockResolvedValue({});
+
+			const result = await getUIBundleId();
+
+			expect(result).toBe("");
+		});
+	});
+
+	describe("isConfiguredUIBundleId", () => {
+		it("returns true for a well-formed 9YE-shaped UIBundle id", () => {
+			expect(isConfiguredUIBundleId("9YE000001abcdEFGHi")).toBe(true);
+		});
+
+		it("returns false for a 0ap-shaped (wrong prefix) id", () => {
+			expect(isConfiguredUIBundleId("0apSG000002dvWjYAI")).toBe(false);
+		});
+
+		it("returns false for an arbitrary non-empty string", () => {
+			expect(isConfiguredUIBundleId("test123")).toBe(false);
+		});
+
+		it("returns false for empty string", () => {
+			expect(isConfiguredUIBundleId("")).toBe(false);
+		});
+
+		it("returns false for whitespace-only string", () => {
+			expect(isConfiguredUIBundleId("   ")).toBe(false);
+		});
+
+		it("returns false for tab-only string", () => {
+			expect(isConfiguredUIBundleId("\t\t")).toBe(false);
+		});
+	});
+});

package/dist/force-app/main/default/uiBundles/propertymanagementapp/src/features/search/adapters/cms/__tests__/searchableContentTypesService.test.ts

@@ -0,0 +1,153 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+/**
+ * Tests for fetchSearchableContentTypes — pagination loop, invalid channelId
+ * throwing before any fetch, non-searchable / invalid-FQN filtering, and the
+ * hard-coded pageSize=25 on every request.
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+const connectGetJson = vi.fn();
+
+vi.mock("../api/apiUtils", () => ({
+	connectGetJson: (url: string) => connectGetJson(url),
+	// keep the real path helpers so URL assertions are meaningful
+	connectUrl: (subPath: string) => `/services/data/v65.0/connect${subPath}`,
+	safeEncodePath: (s: string) => encodeURIComponent(s),
+}));
+
+import { fetchSearchableContentTypes } from "../api/searchableContentTypesService";
+
+const VALID_CHANNEL = "0ap000000000001";
+
+/**
+ * Builds one raw entry in the real Connect v68 shape: the prefixed FQN is in
+ * `id`, `name` is the bare developer name, `label` is the display name.
+ */
+function entry(fqn: string, searchable = true, label?: string) {
+	const bare = fqn.replace(/^sfdc_cms__/, "");
+	return {
+		id: fqn,
+		name: bare,
+		label: label ?? bare.charAt(0).toUpperCase() + bare.slice(1),
+		isSearchable: searchable,
+	};
+}
+
+beforeEach(() => {
+	connectGetJson.mockReset();
+});
+
+describe("fetchSearchableContentTypes", () => {
+	it("throws on an invalid channel id before any fetch", async () => {
+		await expect(fetchSearchableContentTypes("bad-id")).rejects.toThrow(/Invalid CMS channel id/);
+		expect(connectGetJson).not.toHaveBeenCalled();
+	});
+
+	it("paginates: a full page (25) then a short page, concatenating results", async () => {
+		const fullPage = Array.from({ length: 25 }, (_, i) => entry(`sfdc_cms__type${i}`));
+		const shortPage = [entry("sfdc_cms__news"), entry("sfdc_cms__blogPost")];
+		connectGetJson
+			.mockResolvedValueOnce({ items: fullPage })
+			.mockResolvedValueOnce({ items: shortPage });
+
+		const result = await fetchSearchableContentTypes(VALID_CHANNEL);
+		const fqns = result.map((ct) => ct.fqn);
+
+		expect(connectGetJson).toHaveBeenCalledTimes(2);
+		expect(result).toHaveLength(27);
+		expect(fqns).toContain("sfdc_cms__news");
+		expect(fqns).toContain("sfdc_cms__blogPost");
+	});
+
+	it("stops after the first page when it is short", async () => {
+		connectGetJson.mockResolvedValueOnce({ items: [entry("sfdc_cms__news")] });
+		const result = await fetchSearchableContentTypes(VALID_CHANNEL);
+		expect(connectGetJson).toHaveBeenCalledTimes(1);
+		expect(result).toEqual([{ fqn: "sfdc_cms__news", label: "News" }]);
+	});
+
+	it("uses the server-provided label (not one derived from the name)", async () => {
+		connectGetJson.mockResolvedValueOnce({
+			items: [
+				{
+					id: "sfdc_cms__pressRelease",
+					name: "pressRelease",
+					label: "Press Release",
+					isSearchable: true,
+				},
+				{ id: "sfdc_cms__image", name: "image", label: "Image", isSearchable: true },
+			],
+		});
+		const result = await fetchSearchableContentTypes(VALID_CHANNEL);
+		expect(result).toEqual([
+			{ fqn: "sfdc_cms__pressRelease", label: "Press Release" },
+			{ fqn: "sfdc_cms__image", label: "Image" },
+		]);
+	});
+
+	it("falls back to a derived label when the server omits one", async () => {
+		connectGetJson.mockResolvedValueOnce({
+			items: [{ id: "sfdc_cms__blogPost", name: "blogPost", isSearchable: true }],
+		});
+		const result = await fetchSearchableContentTypes(VALID_CHANNEL);
+		expect(result).toEqual([{ fqn: "sfdc_cms__blogPost", label: "Blog Post" }]);
+	});
+
+	it("reads the FQN from id, not the bare name (which would fail FQN validation)", async () => {
+		connectGetJson.mockResolvedValueOnce({
+			// Real shape: id carries the prefixed FQN, name is bare.
+			items: [{ id: "sfdc_cms__news", name: "news", label: "News", isSearchable: true }],
+		});
+		const result = await fetchSearchableContentTypes(VALID_CHANNEL);
+		expect(result).toEqual([{ fqn: "sfdc_cms__news", label: "News" }]);
+	});
+
+	it("filters out non-searchable and invalid-FQN entries", async () => {
+		connectGetJson.mockResolvedValueOnce({
+			items: [
+				entry("sfdc_cms__news", true),
+				entry("sfdc_cms__hidden", false), // not searchable
+				{ id: "0jNxx0000000001", name: "legacy", label: "Legacy", isSearchable: true }, // id is a bare entity id, not an FQN
+				entry("sfdc_cms__blogPost", true, "Blog Post"),
+			],
+		});
+		const result = await fetchSearchableContentTypes(VALID_CHANNEL);
+		expect(result).toEqual([
+			{ fqn: "sfdc_cms__news", label: "News" },
+			{ fqn: "sfdc_cms__blogPost", label: "Blog Post" },
+		]);
+	});
+
+	it("requests pageSize=25 on every call and increments page", async () => {
+		const fullPage = Array.from({ length: 25 }, (_, i) => entry(`sfdc_cms__type${i}`));
+		connectGetJson.mockResolvedValueOnce({ items: fullPage }).mockResolvedValueOnce({ items: [] });
+
+		await fetchSearchableContentTypes(VALID_CHANNEL);
+
+		const urls = connectGetJson.mock.calls.map((c) => c[0] as string);
+		expect(urls[0]).toContain("page=0");
+		expect(urls[0]).toContain("pageSize=25");
+		expect(urls[1]).toContain("page=1");
+		expect(urls[1]).toContain("pageSize=25");
+		expect(urls.every((u) => u.includes("pageSize=25"))).toBe(true);
+	});
+
+	it("accepts a top-level array payload", async () => {
+		connectGetJson.mockResolvedValueOnce([entry("sfdc_cms__news")]);
+		const result = await fetchSearchableContentTypes(VALID_CHANNEL);
+		expect(result).toEqual([{ fqn: "sfdc_cms__news", label: "News" }]);
+	});
+
+	it("de-duplicates repeated FQNs", async () => {
+		connectGetJson.mockResolvedValueOnce({
+			items: [entry("sfdc_cms__news"), entry("sfdc_cms__news")],
+		});
+		const result = await fetchSearchableContentTypes(VALID_CHANNEL);
+		expect(result).toEqual([{ fqn: "sfdc_cms__news", label: "News" }]);
+	});
+});

package/dist/force-app/main/default/uiBundles/propertymanagementapp/src/features/search/adapters/cms/api/apiUtils.ts

@@ -0,0 +1,56 @@
+/**
+ * Self-contained CMS Connect REST helpers (URL builder + authenticated GET).
+ */
+
+import { createDataSDK } from "@salesforce/platform-sdk";
+
+// The build injects the org's API version via `__SF_API_VERSION__`; the literal
+// is only a fallback for environments (e.g. unit tests) where it is undefined.
+declare const __SF_API_VERSION__: string;
+
+/** Project-standard API version, mirroring `@salesforce/ui-bundle/api`'s clients. */
+const API_VERSION: string = typeof __SF_API_VERSION__ !== "undefined" ? __SF_API_VERSION__ : "65.0";
+
+/**
+ * The bundle's build-time API version as a number (e.g. `68.0`), i.e. the
+ * version the SDK's GraphQL/REST requests are actually issued at. `0` when it
+ * cannot be parsed. Distinct from the org's advertised max version.
+ */
+export function getBuildApiVersion(): number {
+	const v = Number.parseFloat(API_VERSION);
+	return Number.isFinite(v) ? v : 0;
+}
+
+/**
+ * Percent-encodes a single path segment (SSRF / path-injection guard). Mirrors
+ * the reference `safeEncodePath`.
+ */
+export function safeEncodePath(segment: string): string {
+	return encodeURIComponent(segment);
+}
+
+/** Builds an absolute Connect REST URL from a version-relative sub-path. */
+export function connectUrl(subPath: string): string {
+	const normalized = subPath.startsWith("/") ? subPath : `/${subPath}`;
+	return `/services/data/v${API_VERSION}/connect${normalized}`;
+}
+
+/**
+ * GETs a Connect JSON resource via the platform SDK's authenticated `fetch`
+ * and returns the parsed body. Throws on SDK-init failure or a non-OK response
+ * (the caller decides how a whole-request failure surfaces).
+ */
+export async function connectGetJson<T = unknown>(url: string): Promise<T> {
+	const sdk = await createDataSDK();
+	if (!sdk?.fetch) {
+		throw new Error("Failed to initialize data SDK for CMS REST call");
+	}
+	const response = await sdk.fetch(url, {
+		method: "GET",
+		headers: { Accept: "application/json" },
+	});
+	if (!response.ok) {
+		throw new Error(`CMS REST request failed: ${response.status} ${response.statusText}`);
+	}
+	return (await response.json()) as T;
+}